{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Configurations for Colab"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "IN_COLAB = \"google.colab\" in sys.modules\n",
    "\n",
    "if IN_COLAB:\n",
    "    !apt install python-opengl\n",
    "    !apt install ffmpeg\n",
    "    !apt install xvfb\n",
    "    !pip install pyvirtualdisplay\n",
    "    from pyvirtualdisplay import Display\n",
    "    \n",
    "    # Start virtual display\n",
    "    dis = Display(visible=0, size=(400, 400))\n",
    "    dis.start()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 02. Double DQN\n",
    "\n",
    "[van Hasselt et al., \"Deep Reinforcement Learning with Double Q-learning.\" arXiv preprint arXiv:1509.06461, 2015.](https://arxiv.org/pdf/1509.06461.pdf)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "Let's take a close look at the difference between DQN and Double-DQN. The max operator in standard Q-learning and DQN uses the same values both to select and to evaluate an action. This makes it more likely to select overestimated values, resulting in overoptimistic value estimates.\n",
    "\n",
    "$$\n",
    "\\theta_{t+1} = \\theta_t + \\alpha \\big(Y_t^Q - Q(S_t, A_t; \\theta_t)\\big) \\cdot \\nabla_{\\theta_t} Q(S_t, A_t; \\theta_t),\\\\\n",
    "\\text{where } \\alpha \\text{ is a scalar step size and the target } Y_t^Q \\text{is defined as }\\\\\n",
    "Y_t^Q = R_{t+1} + \\gamma \\max_a Q(S_{t+1}, a; \\theta_t).\n",
    "$$\n",
    "\n",
    "In Double Q-learning ([van Hasselt 2010](https://papers.nips.cc/paper/3964-double-q-learning.pdf)), two value functions are learned by assigning experiences randomly to update one of the two value functions, resulting in two sets of weights, $\\theta$ and $\\theta'$. For each update, one set of weights is used to determine the greedy policy and the other to determine its value. For a clear comparison, we can untangle the selection and evaluation in Q-learning and rewrite DQN's target as\n",
    "\n",
    "$$\n",
    "Y_t^Q = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t).\n",
    "$$\n",
    "\n",
    "The Double Q-learning error can then be written as\n",
    "\n",
    "$$\n",
    "Y_t^{DoubleQ} = R_{t+1} + \\gamma Q(S_{t+1}, \\arg\\max_a Q(S_{t+1}, a; \\theta_t); \\theta_t').\n",
    "$$\n",
    "\n",
    "The idea of Double Q-learning is to reduce overestimations by decomposing the max operation in the target into action selection and action evaluation. Although not fully decoupled, the target network in the DQN architecture provides a natural candidate for the second value function, without having to introduce additional networks. In conclusion, the weights of the second network $\\theta_t'$ are replaced with the weights of the target network for the evaluation of the current greedy policy. This makes just a small change in calculating the target value of DQN loss.\n",
    "\n",
    "##### DQN:\n",
    "\n",
    "```\n",
    "target = reward + gamma * dqn_target(next_state).max(dim=1, keepdim=True)[0]\n",
    "```\n",
    "\n",
    "##### DoubleDQN:\n",
    "\n",
    "```\n",
    "selected_action = dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "target = reward + gamma * dqn_target(next_state).gather(1, selected_action)\n",
    "```\n",
    "      "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "from typing import Dict, List, Tuple\n",
    "\n",
    "import gym\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torch.optim as optim\n",
    "from IPython.display import clear_output"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Replay buffer\n",
    "\n",
    "Please see *01.dqn.ipynb* for detailed description."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ReplayBuffer:\n",
    "    \"\"\"A simple numpy replay buffer.\"\"\"\n",
    "\n",
    "    def __init__(self, obs_dim: int, size: int, batch_size: int = 32):\n",
    "        self.obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.next_obs_buf = np.zeros([size, obs_dim], dtype=np.float32)\n",
    "        self.acts_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.rews_buf = np.zeros([size], dtype=np.float32)\n",
    "        self.done_buf = np.zeros(size, dtype=np.float32)\n",
    "        self.max_size, self.batch_size = size, batch_size\n",
    "        self.ptr, self.size, = 0, 0\n",
    "\n",
    "    def store(\n",
    "        self,\n",
    "        obs: np.ndarray,\n",
    "        act: np.ndarray, \n",
    "        rew: float, \n",
    "        next_obs: np.ndarray, \n",
    "        done: bool,\n",
    "    ):\n",
    "        self.obs_buf[self.ptr] = obs\n",
    "        self.next_obs_buf[self.ptr] = next_obs\n",
    "        self.acts_buf[self.ptr] = act\n",
    "        self.rews_buf[self.ptr] = rew\n",
    "        self.done_buf[self.ptr] = done\n",
    "        self.ptr = (self.ptr + 1) % self.max_size\n",
    "        self.size = min(self.size + 1, self.max_size)\n",
    "\n",
    "    def sample_batch(self) -> Dict[str, np.ndarray]:\n",
    "        idxs = np.random.choice(self.size, size=self.batch_size, replace=False)\n",
    "        return dict(obs=self.obs_buf[idxs],\n",
    "                    next_obs=self.next_obs_buf[idxs],\n",
    "                    acts=self.acts_buf[idxs],\n",
    "                    rews=self.rews_buf[idxs],\n",
    "                    done=self.done_buf[idxs])\n",
    "\n",
    "    def __len__(self) -> int:\n",
    "        return self.size"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Network\n",
    "\n",
    "We are going to use a simple network architecture with three fully connected layers and two non-linearity functions (ReLU)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Network(nn.Module):\n",
    "    def __init__(self, in_dim: int, out_dim: int):\n",
    "        \"\"\"Initialization.\"\"\"\n",
    "        super(Network, self).__init__()\n",
    "\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(in_dim, 128), \n",
    "            nn.ReLU(),\n",
    "            nn.Linear(128, 128), \n",
    "            nn.ReLU(), \n",
    "            nn.Linear(128, out_dim)\n",
    "        )\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        \"\"\"Forward method implementation.\"\"\"\n",
    "        return self.layers(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Double DQN Agent\n",
    "\n",
    "Here is a summary of DQNAgent class.\n",
    "\n",
    "| Method           | Note                                                 |\n",
    "| ---              | ---                                                  |\n",
    "|select_action     | select an action from the input state.               |\n",
    "|step              | take an action and return the response of the env.   |\n",
    "|compute_dqn_loss  | return dqn loss.                                     |\n",
    "|update_model      | update the model by gradient descent.                |\n",
    "|target_hard_update| hard update from the local model to the target model.|\n",
    "|train             | train the agent during num_frames.                   |\n",
    "|test              | test the agent (1 episode).                          |\n",
    "|plot              | plot the training progresses.                        |\n",
    "\n",
    "We use `self.dqn` instead of `self.dqn_target` for action selection.\n",
    "\n",
    "```\n",
    "\n",
    "        next_q_value = self.dqn_target(next_state).gather(\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)  # Double DQN\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DQNAgent:\n",
    "    \"\"\"DQN Agent interacting with environment.\n",
    "    \n",
    "    Attribute:\n",
    "        env (gym.Env): openAI Gym environment\n",
    "        memory (ReplayBuffer): replay memory to store transitions\n",
    "        batch_size (int): batch size for sampling\n",
    "        epsilon (float): parameter for epsilon greedy policy\n",
    "        epsilon_decay (float): step size to decrease epsilon\n",
    "        max_epsilon (float): max value of epsilon\n",
    "        min_epsilon (float): min value of epsilon\n",
    "        target_update (int): period for target model's hard update\n",
    "        gamma (float): discount factor\n",
    "        dqn (Network): model to train and select actions\n",
    "        dqn_target (Network): target model to update\n",
    "        optimizer (torch.optim): optimizer for training dqn\n",
    "        transition (list): transition information including \n",
    "                           state, action, reward, next_state, done\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self, \n",
    "        env: gym.Env,\n",
    "        memory_size: int,\n",
    "        batch_size: int,\n",
    "        target_update: int,\n",
    "        epsilon_decay: float,\n",
    "        max_epsilon: float = 1.0,\n",
    "        min_epsilon: float = 0.1,\n",
    "        gamma: float = 0.99,\n",
    "    ):\n",
    "        \"\"\"Initialization.\n",
    "        \n",
    "        Args:\n",
    "            env (gym.Env): openAI Gym environment\n",
    "            memory_size (int): length of memory\n",
    "            batch_size (int): batch size for sampling\n",
    "            target_update (int): period for target model's hard update\n",
    "            epsilon_decay (float): step size to decrease epsilon\n",
    "            lr (float): learning rate\n",
    "            max_epsilon (float): max value of epsilon\n",
    "            min_epsilon (float): min value of epsilon\n",
    "            gamma (float): discount factor\n",
    "        \"\"\"\n",
    "        obs_dim = env.observation_space.shape[0]\n",
    "        action_dim = env.action_space.n\n",
    "        \n",
    "        self.env = env\n",
    "        self.memory = ReplayBuffer(obs_dim, memory_size, batch_size)\n",
    "        self.batch_size = batch_size\n",
    "        self.epsilon = max_epsilon\n",
    "        self.epsilon_decay = epsilon_decay\n",
    "        self.max_epsilon = max_epsilon\n",
    "        self.min_epsilon = min_epsilon\n",
    "        self.target_update = target_update\n",
    "        self.gamma = gamma\n",
    "        \n",
    "        # device: cpu / gpu\n",
    "        self.device = torch.device(\n",
    "            \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "        )\n",
    "        print(self.device)\n",
    "\n",
    "        # networks: dqn, dqn_target\n",
    "        self.dqn = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target = Network(obs_dim, action_dim).to(self.device)\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "        self.dqn_target.eval()\n",
    "        \n",
    "        # optimizer\n",
    "        self.optimizer = optim.Adam(self.dqn.parameters())\n",
    "\n",
    "        # transition to store in memory\n",
    "        self.transition = list()\n",
    "        \n",
    "        # mode: train / test\n",
    "        self.is_test = False\n",
    "\n",
    "    def select_action(self, state: np.ndarray) -> np.ndarray:\n",
    "        \"\"\"Select an action from the input state.\"\"\"\n",
    "        # epsilon greedy policy\n",
    "        if self.epsilon > np.random.random():\n",
    "            selected_action = self.env.action_space.sample()\n",
    "        else:\n",
    "            selected_action = self.dqn(\n",
    "                torch.FloatTensor(state).to(self.device)\n",
    "            ).argmax()\n",
    "            selected_action = selected_action.detach().cpu().numpy()\n",
    "        \n",
    "        if not self.is_test:\n",
    "            self.transition = [state, selected_action]\n",
    "        \n",
    "        return selected_action\n",
    "\n",
    "    def step(self, action: np.ndarray) -> Tuple[np.ndarray, np.float64, bool]:\n",
    "        \"\"\"Take an action and return the response of the env.\"\"\"\n",
    "        next_state, reward, done, _ = self.env.step(action)\n",
    "\n",
    "        if not self.is_test:\n",
    "            self.transition += [reward, next_state, done]\n",
    "            self.memory.store(*self.transition)\n",
    "    \n",
    "        return next_state, reward, done\n",
    "\n",
    "    def update_model(self) -> torch.Tensor:\n",
    "        \"\"\"Update the model by gradient descent.\"\"\"\n",
    "        samples = self.memory.sample_batch()\n",
    "\n",
    "        loss = self._compute_dqn_loss(samples)\n",
    "\n",
    "        self.optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        self.optimizer.step()\n",
    "\n",
    "        return loss.item()\n",
    "        \n",
    "    def train(self, num_frames: int, plotting_interval: int = 200):\n",
    "        \"\"\"Train the agent.\"\"\"\n",
    "        self.is_test = False\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        update_cnt = 0\n",
    "        epsilons = []\n",
    "        losses = []\n",
    "        scores = []\n",
    "        score = 0\n",
    "\n",
    "        for frame_idx in range(1, num_frames + 1):\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "\n",
    "            # if episode ends\n",
    "            if done:\n",
    "                state = self.env.reset()\n",
    "                scores.append(score)\n",
    "                score = 0\n",
    "\n",
    "            # if training is ready\n",
    "            if len(self.memory) >= self.batch_size:\n",
    "                loss = self.update_model()\n",
    "                losses.append(loss)\n",
    "                update_cnt += 1\n",
    "                \n",
    "                # linearly decrease epsilon\n",
    "                self.epsilon = max(\n",
    "                    self.min_epsilon, self.epsilon - (\n",
    "                        self.max_epsilon - self.min_epsilon\n",
    "                    ) * self.epsilon_decay\n",
    "                )\n",
    "                epsilons.append(self.epsilon)\n",
    "                \n",
    "                # if hard update is needed\n",
    "                if update_cnt % self.target_update == 0:\n",
    "                    self._target_hard_update()\n",
    "\n",
    "            # plotting\n",
    "            if frame_idx % plotting_interval == 0:\n",
    "                self._plot(frame_idx, scores, losses, epsilons)\n",
    "                \n",
    "        self.env.close()\n",
    "                \n",
    "    def test(self) -> None:\n",
    "        \"\"\"Test the agent.\"\"\"\n",
    "        self.is_test = True\n",
    "        \n",
    "        state = self.env.reset()\n",
    "        done = False\n",
    "        score = 0\n",
    "        \n",
    "        while not done:\n",
    "            self.env.render()\n",
    "            action = self.select_action(state)\n",
    "            next_state, reward, done = self.step(action)\n",
    "\n",
    "            state = next_state\n",
    "            score += reward\n",
    "        \n",
    "        print(\"score: \", score)\n",
    "        self.env.close()\n",
    "\n",
    "    def _compute_dqn_loss(self, samples: Dict[str, np.ndarray]) -> torch.Tensor:\n",
    "        \"\"\"Return dqn loss.\"\"\"\n",
    "        device = self.device  # for shortening the following lines\n",
    "        state = torch.FloatTensor(samples[\"obs\"]).to(device)\n",
    "        next_state = torch.FloatTensor(samples[\"next_obs\"]).to(device)\n",
    "        action = torch.LongTensor(samples[\"acts\"].reshape(-1, 1)).to(device)\n",
    "        reward = torch.FloatTensor(samples[\"rews\"].reshape(-1, 1)).to(device)\n",
    "        done = torch.FloatTensor(samples[\"done\"].reshape(-1, 1)).to(device)\n",
    "        \n",
    "        # G_t   = r + gamma * v(s_{t+1})  if state != Terminal\n",
    "        #       = r                       otherwise\n",
    "        curr_q_value = self.dqn(state).gather(1, action)\n",
    "        next_q_value = self.dqn_target(next_state).gather(  # Double DQN\n",
    "            1, self.dqn(next_state).argmax(dim=1, keepdim=True)\n",
    "        ).detach()\n",
    "        mask = 1 - done\n",
    "        target = (reward + self.gamma * next_q_value * mask).to(self.device)\n",
    "\n",
    "        # calculate dqn loss\n",
    "        loss = F.smooth_l1_loss(curr_q_value, target)\n",
    "\n",
    "        return loss\n",
    "    \n",
    "    def _target_hard_update(self):\n",
    "        \"\"\"Hard update: target <- local.\"\"\"\n",
    "        self.dqn_target.load_state_dict(self.dqn.state_dict())\n",
    "                \n",
    "    def _plot(\n",
    "        self, \n",
    "        frame_idx: int, \n",
    "        scores: List[float], \n",
    "        losses: List[float], \n",
    "        epsilons: List[float],\n",
    "    ):\n",
    "        \"\"\"Plot the training progresses.\"\"\"\n",
    "        clear_output(True)\n",
    "        plt.figure(figsize=(20, 5))\n",
    "        plt.subplot(131)\n",
    "        plt.title('frame %s. score: %s' % (frame_idx, np.mean(scores[-10:])))\n",
    "        plt.plot(scores)\n",
    "        plt.subplot(132)\n",
    "        plt.title('loss')\n",
    "        plt.plot(losses)\n",
    "        plt.subplot(133)\n",
    "        plt.title('epsilons')\n",
    "        plt.plot(epsilons)\n",
    "        plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Environment\n",
    "\n",
    "You can see the [code](https://github.com/openai/gym/blob/master/gym/envs/classic_control/cartpole.py) and [configurations](https://github.com/openai/gym/blob/master/gym/envs/__init__.py#L53) of CartPole-v0 from OpenAI's repository."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "# environment\n",
    "env_id = \"CartPole-v0\"\n",
    "env = gym.make(env_id)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set random seed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[777]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "seed = 777\n",
    "\n",
    "def seed_torch(seed):\n",
    "    torch.manual_seed(seed)\n",
    "    if torch.backends.cudnn.enabled:\n",
    "        torch.backends.cudnn.benchmark = False\n",
    "        torch.backends.cudnn.deterministic = True\n",
    "\n",
    "np.random.seed(seed)\n",
    "seed_torch(seed)\n",
    "env.seed(seed)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Initialize"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "cuda\n"
     ]
    }
   ],
   "source": [
    "# parameters\n",
    "num_frames = 20000\n",
    "memory_size = 1000\n",
    "batch_size = 32\n",
    "target_update = 200\n",
    "epsilon_decay = 1 / 2000\n",
    "\n",
    "# train\n",
    "agent = DQNAgent(env, memory_size, batch_size, target_update, epsilon_decay)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAABIUAAAE/CAYAAADYJXMZAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8li6FKAAAgAElEQVR4nOy9eZgkZ3nle96IyK26q7tadGur1oJACCRhwDSLwchmMWDgGuMNsM2AAWuwzdh4fB8P29gYDNjja2P7egxXIKwBjACDsWVb7DsSQkiW0AYIrai19lrVXUtmRsR7/4j4Ir6IjFwiK6sys+r8nqefyiUi88us7MyMU+ecV1QVhBBCCCGEEEIIIWRr4Yx7AYQQQgghhBBCCCFk46EoRAghhBBCCCGEELIFoShECCGEEEIIIYQQsgWhKEQIIYQQQgghhBCyBaEoRAghhBBCCCGEELIFoShECCGEEEIIIYQQsgWhKLSJEZFzROR6ETkmIr877vUQQgghk4yI3CUizxn3OgghhEwfIvJmEflAfPpMEVER8ca9LkL6QVFoc/OHAL6iqrOq+rfjXoyNiDxKRP5VRA6IyGER+ZyInJPb5vdF5AERWRSRD4pIzbruTBH5iogsi8j381/i17LvNCMi58fP5UER0YLrPyIi98fPy60i8trc9c+On5Pl+Dk6o8d9vUNEbhQRX0Tetg4PhxBCCCGEkKlAVd+lqq/tvyUhkwVFoc3NGQBu7naliLgbuJY8cwAuA3AOgJMAXA3gX82VIvI8AG8E8GxEj+MsAH9i7X8pgOsAPAzAWwB8UkT2rHXfcSIRa/0/2QbwCQCv6XL9uwGcqao7APwcgD8VkSfG978bwD8D+J8ATgBwDYCP97iv2xAJj/+xxjUTQgghhBBCCBkDFIU2KSLyZQDPBPB3InI8duZcIiLvFZHLRWQJwDNF5IUicl3sHLnHdnxYtsffiK87IiKvE5EnicgNInJURP4ud7+vFpHvxdt+rpvTRFWvVtWLVfWwqrYBvAfAOSLysHiTVwK4WFVvVtUjAN4B4FXxfTwKwI8D+GNVXVHVTwG4EcAvjmDffs/r/xCRe+NI3g9E5Nnx5W5sGb09vu5aETktvu5pIvIdEVmIfz7Nur2visg7ReQKAMsAzhKRnSJycezouVdE/nRQAU9Vf6CqF6OLGBg/J01zNv73iPj8LwC4WVX/SVVXAbwNwONE5NFdbuv/qOpnABwbZG2EEDItiEhNRP5aRO6L//21cZyKyG4R+ff4M/CwiHzDCPrdPiMIIYRMHiJyqoh8SqLkwp0S122IyNtE5JMi8vH4/fw/ReRx1n7djgfeJiIf6XFfl8WfG7eJyG9a171NRD4hIh+Kb/NmEdnX7/4IGRUUhTYpqvosAN8A8HpV3a6qt8ZX/SqAdwKYBfBNAEsA/gsi584LAfyWiPx87uaeAuBsAC8F8NeI3DXPAXAegF8RkZ8CABF5MYA3IxIX9sT3f+mAS74AwAOqeig+fx6A71rXfxfASbFodB6AO1T1WO7680awb1ckire9HsCTVHUWwPMA3BVf/d8BvBzACwDsAPBqAMsicgIiJ83fInIm/RWA/7DELwB4BYALEf1O7gZwCQAfwCMBPAHAcwG8Nl7D6fGByOn91tvjcfy9iCwD+D6A+wFcHl+Ved5UdQnA7RjguSGEkE3GWwA8FcDjATwOwJMBvDW+7g8A7Ef0OXcSos897fMZQQghZIKIxfx/Q/Tddx5RwuANEiUOAODFAP4JkXv+owD+RUQqa3iv/xiiz45TAfwSgHeJyLOs638u3sakKf4uXic/W8i6Q1Fo6/GvqnqFqoaquqqqX1XVG+PzNyAScX4qt8874m0/j0hEulRVH1LVexEJP0+It3sdgHer6vdU1QfwLgCP7+YWMojIXgD/G5GwYtgOYME6b07PFlxnrp8dwb69CADUAJwrIhVVvUtVb4+vey2At8ZOHVXV78YC1wsB/FBVP6yqvqpeikiM+b+s270kdvD4iD54XgDgDaq6pKoPIXJRvQwAVPVHqjqnqj8aYL2FqOpvx4/3GYjiYsY5tJbnhhBCNhO/BuDt8WfdAUQR5FfE17UBnALgDFVtq+o3VFXR+zOCEELIZPEkAHtU9e2q2lLVOwC8H/F3bgDXquon40TDXwGoI/pjQen3+jg98HQA/yM+proewAcQ/WHe8E1VvVxVAwAfRvQHCQxzf4SUhaLQ1uMe+4yIPEWiQuEDIrKASNjZndvnQev0SsH57fHpMwD8TexkOQrgMABBpL4XIlGXz+cB/H0smBiOI3LcGMzpYwXXmeuN+2ct+3ZFVW8D8AZEsaqHRORjInJqfPVpiFw1eU5F5P6xuRvZ58T+nZwBoALgfut5/P8AnNhvfWVQ1UBVvwlgL4Dfii8e+rkhhJBNRv69++74MgD4C0Sdap8XkTtE5I1A388IQgghk8UZAE4137fj79xvRuQABazv56oaInb5DPlefyqAw7mkQv544AHr9DKAuoh4/GwhGwFFoa1HfiLVRxFZFE9T1Z0A3odIyBmGewD819jJYv41VPXKoo1FZBciQegyVX1n7uqbkSrkiE8/GLtvbkbUvTObu/7mEezbE1X9qKr+JKIPEgXw59Zjf0TBLvfF29qcDuBe+2at0/cgcu7stp7DHaq6XhEuD+m6M8+biGyLrxvouSGEkE1E/r379PgyqOoxVf0DVT0Lkd3/v5t+hx6fEYQQQiaLewDcmTtumVXVF8TXn2Y2jKNme5F+DpR9r78PwAm544/88UBX+NlC1huKQmQWkXK9KiJPRtQ5NCzvA/AmETkPAOLC5F8u2lBEdgD4HIArVPWNBZt8CMBrRORcEZlD1OVwCQDE/UjXA/hjEamLyEsA/BiAT41g366IyDki8qy4bHQVkUsqjK/+AIB3iMjZEvFjcW/Q5QAeJSK/KiKeiLwUwLkA/r3oPlT1fkRC2V+KyA4RcUTkEaa3aYA1iojUAVTj83VJy1FPFJGXich2iYqxn4eoB+lL8e6fBnC+iPxifBt/BOAGVf1+l/uqxNs5ALz4vsY50Y4QQkbFpQDeKiJ7JJrM+EcAPgIAIvIiEXmkiAiiiG0AIOzzGUEIIWSyuBrAsbjEuRF/Nz5fRJ4UX/9EEfkFEfEQOXWaAK4a5r1eVe8BcCWAd8ffl38M0aTgwlJqG362kI2AohD5bQBvF5FjiL70fmLYG1LVTyNSrj8mIosAbgLws102fwmiLO9vSDQdzfw7Pb6tzwL4XwC+AuBHiCyWf2zt/zIA+wAcAfBnAH4p7n1Y074i8msi0s0ZU4u3P4jI4nkigDfF1/0Voufu8wAWAVwMoBG7k16EqJj0EKIR7i9S1YNd7gOI8sVVALfEa/wkov4KUzSdPE8FnIHow8I8hhUAP4hPK6Ko2P74dv8fRN1FlwFA/Bz8IqIi8iOICsZNrhoi8j4ReZ91X++Pb//liEpZV5B2bhBCyDTzpwCuAXADogmV/xlfBkSDF76IKHL7LUTx56+g92cEIYSQCSLu7nkRooECdyJ67/4AgJ3xJv+KaMjOEUTfb38h7hca9r3+5QDOROQa+jSiSchfHGA/fraQdUeibkRCCCGEEEIIIWRrIyJvA/BIVf31ca+FkI2ATiFCCCGEEEIIIYSQLQhFIUIIIYQQQgghhJAtCONjhBBCCCGEEEIIIVsQOoUIIYQQQgghhBBCtiAUhQghhBBCCCGEEEK2IN64FwAAu3fv1jPPPHPcyyCEkInk2muvPaiqe8a9jlEjIncBOAYgAOCr6r5u2/JzghBCitmsnxFl4ecEIYQU0+9zYiJEoTPPPBPXXHPNuJdBCCETiYjcPe41rCPPVNWD/Tbi5wQhhBSzyT8jBoafE4QQUky/zwnGxwghhBBCCCGEEEK2IBSFCCGEjAsF8HkRuVZELsxfKSIXisg1InLNgQMHxrA8QgghhBBCNjcUhQghhIyLn1TVHwfwswB+R0QusK9U1YtUdZ+q7tuzZ8vXZRBCCCGEEDJyKAoRQggZC6p6b/zzIQCfBvDk8a6IEEIIIYSQrQVFIUIIIRuOiGwTkVlzGsBzAdw03lURQgghhBCytZiI6WOEEEK2HCcB+LSIANFn0UdV9bPjXRIhhBBCCCFbC4pChBBCNhxVvQPA48a9DkIIIRuLiHwQwIsAPKSq5xdcLwD+BsALACwDeJWq/ufGrpIQQrYOfeNjInKaiHxFRG4RkZtF5Pfiy08QkS+IyA/jn7viy0VE/lZEbhORG0Tkx9f7QRBCCCGEEEKmgksAPL/H9T8L4Oz434UA3rsBayKEkC3LIJ1CPoA/UNVzATwV0YSYcwG8EcCXVPVsAF+KzwN8IyeEEEIIIYQUoKpfB3C4xyYvBvAhjbgKwJyInLIxqyOEkK1H3/iYqt4P4P749DER+R6AeURv2D8db/Z/AHwVwP+A9UYO4CoRmRORU+LbIVsIVcU3bzuIn3zkbsS9IRmuueswHnPKDmyrrT3FGIaKK27vfl+D8MVbHsSB403sqFfwgsee3Pd2ji63cPehZTzutLnM5Z+/+QEcWmol5x++exueetbDSq1FVfG5mx/AkeV2qf3OPnE79p15AgDgW7cfwl2Hlgbar15x8ILHnoKa5+KhY6s4cKyJ807dCQC48raDuPvwcs/9XRE897yTMDdTxfGmj8/ceD/8UEutfaPxHMHzzz8Zs/VKctm9R1ew0vLxyBNnk8u6vbZuuW8Ru2erOHG23nHb9xxeRisI8Yg929f3QRBCyBbl2Gobtz54HE88Y9e4l0JGzzyAe6zz++PL1uVY4is/eAhtP8Rzzzt5PW6eEEImnlJH4yJyJoAnAPg2gJMsoecBRKWhwIBv5CJyISInEU4//fSSyybTwHX3HMUrLr4an/qtn8ATzzghc93xpo+XXnQV/uhF5+KVTztzzfd11Z2H8IqLr8Z//O5PJmJGGR5cXMVrP3RNcv6zb3gGHn3yjp77/MMVd+ED37gDN789dUDfd3QFF3742sx2szUPN/7J80qt557DK3jdR8rH53dvr+Kat/4MAODVl3wHK+1g4H1naxU859yT8Hdfvg1f+t5DuOKNz4Kq4pX/cDXaQX+B59DSo/FbP/0IXHb9fXjzp28svfZx0ApC/NpTzkjO//lnvo+7Di3hstf/ZHLZVXdEr63P/N4z8JhT0tfE6z5yLZ55zh78yYs76hDwrsu/hwPHmvjkbz1tfR8AIYRsUf7rh6/Flbcfwi1vfx5mqqzI3KqM4nji4m/cieNNn6IQIWTLMvCnqIhsB/ApAG9Q1UX7L+aqqiJSyhagqhcBuAgA9u3bN9mWAjIUS00fAHC82SlMLLd8BKHiaEknTDeOr/rxfQ4ugtgcPN4EAPzCE+bxz9fdO9DtLKy0sdQKoKqJg2S5Fa3jHT9/Pn7mMSfhvV+9DR+9+kel19P0o/v/058/H895zEl9to74my/disuuvw9A5DRaaQd49dMfjgsvOKvnfvcvrOAlf38lDi9H7qaDx5tYjcWkUIF2oLjwgrPw6qc/vHB/heIn3v3lZB/z8/O/fwF2WC6cSeLYahs/856vo9kOM5cvtwIci19LhqVWEF/nd2xb9No2+5j9CCGEjJ4b9y8AwMS7UslQ3AvgNOv83viyDkZxPDE/18CXf/DQMLsSQsimYCBRSEQqiAShf1TVf44vftDEwuKcr3k3HfiNnGxu/Nhd0vbDjuvMwXgZJ0vP+4q/FPph530NwkIsTp3xsG0AUlGmF0b8CEKF50q8X3T/e7bXcPLOOmbrFQzzfdXsc8K2Kk7e2RlPKmJHvZI8D0H8c26m0nf/RtUFACyutOOfPkLVeB0a37bX83ZEIiHK3ufknfWJFYVmatFjNms1qCpauder2SbvlgpVu77ewlDhB8O9FgkhhJAtzmUAXi8iHwPwFAAL61lDMb+rgQPHoj+I1Svuet0NIYRMLINMHxMAFwP4nqr+lXXVZQBeGZ9+JYB/tS7/L/EUsqdind/IyeTSjg+Kiw6cjeiyknNfrPW+giH/Yng0FkRO3FEDgA5hoAgjaNl/pTT71bzov5Yjw63JCBFOiXokz5XkvsyajFjVi+1xp5NxyBxbbSeilFlHv34lRwRBThRyhux22gi6rS1UTYS95LKc0GZv63eJ1flhOPRrkRBCCNnMiMilAL4F4BwR2S8irxGR14nI6+JNLgdwB4DbALwfwG+v53rm5xoAogoAQgjZigziFHo6gFcAuFFEro8vezOAPwPwCRF5DYC7AfxKfN3lAF6A6I18GcBvjHTFZGowwkQrPnBeaQVo+SF2zlSwGjuFlkcUsTEujmFt5AtGFJqNRKG8MFDESqtTFDLrqBpRKFZ1wlCT04MwjLDiOg78UKGqiSDhDXCfriOYrXmJKLS4mjqFjJGm3zpcEUtISi+bVMzTkncKRXG57O/eiF3511YY9nIKMdJACCGEFKGqL+9zvQL4nQ1aDuZ3RaLQvUdXcBYHRBBCtiCDTB/7JoBuR3fPLth+Q9/IyeSSRLrig+x3f+Z7uPHeBXz6t5+eiC7Lo4qPGafQAIXIRZhuIzNJqoxTyL5Ps1/FjUQhI4yEqnC6/jfqZFAxxsYIQEGYOlhcp68ZEAAwW/ewuBo9B8dW28n9D+pYcpxOR82Adz0WnOT3kr1c0fm7N9sEOQFIFV2dQoElzBFCCCFkcjFOoXuP0ClECNmaTPBhG5l2jFBjnBcPLTbx4MIqAKDZNvGxETmF1tgpdHSlharnYGcj6sAZRBQynUJt6z7NY807hQItJxAMI6y48X35loNlEKcQAOxoVHBstahTKLq+nzjlSBpdM+LQJMfHpItTSFXRCorjY3kBKFBNXnd5gh4uIkIIIYRMDifvrMORyClECCFbEYpCZN1IiqaTnyFWY7HFOIVGJQr5SX/RkPGx5TbmGhXUKk5mfb1YsYqmDc3EKRSpDokjpaQ+MGiXj425zyC04mMDdAoBsVNoxcdqO0ArCDuKpvtF36YtPiaxayuv1YWxw8f+nQY5B1R22y7xsR59Q4QQQgiZHCqug5N31OkUIoRsWSgKkXXDOGiMe6YVhIm7xhRNjyo+tuai6eU25mYqqMaxr9ZA08eyjw9A4jIxRdPxzXU4UvoxqEPHxkTF/CB1sAzsFKpXcKzZTiJk5v41NOvovb9I+hiDRNAaeOkbTtIp1NETFP20nWJht04h7ZxIZoicQhSFCCGEkGlgflcD++kUIoRsUSgKkXXDCDRtK0a22g6gqomgMrrpY8URn0FZWGljrlFNYl+liqat+2znOoWMqFM2PqYDdvnYeEl8LEx6jkp1Cq34Sdl0frx836JpR6xyaoUj5VxOG023TiHzGIpFoc5YWbex83m3ESGEEEIml/m5Bp1ChJAtC0Uhsm60O+JjilAjN03iFBpZfGytnUJt7GhUEodPmU6hzEj6fKdQEh9bf6eQZ8XHzPNQGTg+FnUKLa5knUIDF01bnUJBqBPdJwT06hSKftq9QuZkXnAMe5RJh8pOIUIIIWRamN/VwAOLq13/2EMIIZsZikJk3cgXTZufq+0wceKsjmr6WLjWTqEW5mYq8FwHjpTrFPKLiqbN9DGn2JHSj3CICJZnFU0bscIduGjaw+Kqj8XYKZQvmu7n+nEsp1Cg2reDaNyICERSR5QhcQoFnU6hzk6h3vExOoUIIYSQ6WDvrhkEoeLBY81xL4UQQjYcikJk3UhH0mcjOc12gGYcHxuVU6i11k6hlahoGgBqntsxgSqPqqaiUNFI+sQphKHWNWhsyybTKRSU6xSarVcQhIqHFqPpcKrRY9RB42MiSR+P6mSXTBscEeR/K73jY+nWyUSyrkXTwwuUhBBCCNlYOJaeELKVoShE1g3fmjpm/1xtp4XTK3HH0Kjua5hOoZYfYrkVYG4mEoWqntM3Ptb0wyRqVBgfc7Mj6csWTZvNB3X6ALlOocQpNNh/8R316LHb41hV7Rhb7/0dSXuTovjYwMseG450/l7M482IQgXTx7qVTxuCUKE6vEhJCCGEkI1jflcsCh1dHvNKCCFk46EoRNYNP5k+lu0WWvWDJJ6lmk7xWtN9JSPpy9/WQtyjs7ORikLNPtPH7NibPZbciAnVXNF0+eljQxRNF3QKlRlJD2T/QhaqDuxYsuNj4RTEx4AoQpbXbLTAKRQUiH/mZDcRMujjJCKEEELI5ECnECFkK0NRiKwb7a5OoSAjuiyPYAJZO+zt3OjFwkoLALBzpgogGiffr1NoxRKF2rn4mOdIIoqYGFX5+Fj0s8wEL+MUagfpOPSBR9I3Op1CoQ7ebeSIJI6acAqKpoE+TqEg/f2mTqGCSFmXmGG3HiJCCCGETB71iovd26uZ70GEELJVoChE1o0gzLp3svGx9GB6ZQRl02YUfDBEfOzocuQUmss4hfqIQlYXUmYkfRAmk8eAND5WNiFnhIhhOoWCUJM1DRo/S5xCR3NOofhpGGwkvdmvXOxtXAik4/eSdgp1RsVs8W+Q+Fiv6wkhhBAyWczPNbCfTiFCyBaEohBZN9pB9gC75Rc7hVZGUDbtr+EgPBGFZqyi6S6i0O0HjiMINSNq+bn4WMW1RKE1F00Pvo+JitmdQvZaemE6he4/uppZQ7KOPjcjdqeQTlGnUMFEMSA3kr7A9ZPEx3qMpAeGEykJIYQQsvHM72rQKUQI2ZJQFCLrRt4hZESilXaQceKMYgJZew3Tx44WdAoViUIHjzfx3Pd8HZffeH/G3ZSZPhZoxilkHDNB6U6h6GcZp5CJitmdQgOPpI+dQtlR7INPQXOnMj42WKdQWCA4pu6hYvHQvA7b7BQihBBCpoL5uQbuPbIykgEohBAyTVAUIutGMhEsFyNbtUbSA6MRhZJJZ2somp5r2J1CnWtaWGkjCBUPLKxmiqYz08f8MCmZBlIxpewXjEG7fGxcu1Oo5Eh60ymUX8Og3UZurmh6KuJjBZ1C5mx2JH30M9MpZISiPkXT7BQihBBCpoP5uQaafoiDx1vjXgohhGwoFIXIumHEkpavUNXEKdRsh1j1g0TwWGmvvWjaCE7DxHUWllsQSXt1al2cQuayxdV2tlPIjo/lO4WSoulya9IBHTo2nt0plIykH2z/muegkptUpqG9jt77i0jyGIOw3LrHRdGEtKRTKLCnyxU5hbLXdd5O9LObaEQIIYSQyWJ+1wwAMEJGCNlyUBQi64Y9Jt4u6V31I6eQ6bFZaQ0XsbnlvkU8sBB14LSCzgP3QTm60sbORiURCapucdF0IgqttDPxMVsYaPthRlwxpqFhp4+VEoXW0CkkIpitZ91CtlOof9F0KiCpat8Ookkgio/lO4UK4mMF/UBJfKyLM41OIUIIIWS64Fh6QshWZQoO3ci0YsbEt4Mw071iiqZ3xcXOw46k/+1/vBZ/++UfAkgFqKE6hZbbyeQxAKhVip1CRihayIlCmZH0XZxCefGhH2b7ATUdAGlUzA/KdwoBaa+Q2SdTND3ASPps0fQUOIV6xcf6TBoz8THV4tdcULAPIYQQQiaX+V2xKHR0ecwrIYSQjYWiEFk3fKtgOisKRSPp52aiDp9hR9IfbwY4turH95XtLyqDcQoZqq6TKVw2pPExP9MpZHfNtIPiTqHyolD0s1+Xj40Rc/ywfKcQgMQpZJ4Lu2i63zrs0uZQo+LpSUcKiqaLnELmpWC/tuz9il5zIZ1ChBBCyFSxs1HBbM2jU4gQsuWgKETWjcByCrUKnEInbItEoWGLpv0wRCsuhDYxnmE6XBZW2tgZC1RANJLeLsI2mPLpxZVsp5DtFGrmRtK71kSwMgzTKWTuNwg1uT+vhNVoRyNyChlRSFUT50y/ddjj3cNQSxVkjwtBZwF4MpLeEoXMNtmR9OnpoteccQp1m05GCCGEkMmDY+kJIVsRikJk3TBiiR9otlOoHaLph4n4MLQoFGhy8L6WkfQLy61MfKzq9XMKtXMj6cPMNnZ8zIgjZZdlHkeZIV6pUyhMYkulnEK17k6hfjfjOpLp0ZmG6WOOCPImn2KnUOeksV6ikC2m0SlECCGETA/zcw3sp1OIELLFoChE1g0Tq2kHIdrWQfZKO0DTD1GvuGhU3EwUqwy2A8lfQ9H08aaP7XGfDhCJQs2CNZn7Wlzxs6KQXTSdi4/Z/TxlGKpoeq2dQjmnUJmiabu0OdwUnUJWPLDIKWSJSfn4mL0dO4UIIYSQ6YFOIULIVoSiEFk3jDsoXzTdbAdYbQeoeQ4aVXfooul2EHY4hYbpFGr5WSGn1sUpZCJli6ttNNupI8g+8M87hUy3TlhSHEi7fAbfx46qraVTaG7GFoUGW8c0ikKDdgoZocjvFh/L3UhgXUenECGTy3LLxy+/70rc+uCxcS+FEDIhzM81cGzVx+Jqe9xLIYSQDYOiEFk30k4hzXYK+ZFTqFZx0Ki4Q8XHwjBysZiDd78g4jMo7UAzQk7Vc9AOtEPIacaPYbkVYHG1jdla5KwJck4hu1PIFDQHJZ1Ca+kU8oftFDKiUNIpNPg6XCdXND0N8TGnqFMofc0aisbL26JQvjeol4uIEDI5XHXHIXznriN49+XfG/dSCCETQjKBjBEyQsgWou8Ro4h8UEQeEpGbrMs+LiLXx//uEpHr48vPFJEV67r3refiyWSTTh8LMwfZK60ALT9E3XMxU3Uzpc2DYoqlzZh4E08bxpkRCTmpiFHzXADocAvZkbKHFptJ5Kzdo1MoiY+V1AaGiY/ZnULm+SnnFBo+PiaSFU+mQBOCI4L8q8U83qbdKZSMl7enj3V3AwU9+oYIIYQQMrns3TUDgKIQIWRr4fXfBJcA+DsAHzIXqOpLzWkR+UsAC9b2t6vq40e1QDK9pPGx7Ej6xXiMfK3iRKLQEJ1C5mDbCDdt4xQqG9MKFX6oGXePEXVM75HBFokeXFzFTNWDI1lRoJVzHZmbLd8pVL5o2u4UCuLnp4xj56lnPQzPevSJyReiUNPY2yBF02rHx6ZAFbIjbwYtjI8VFU2n+7Rzwo/9emB8jBBCCJke5udipxB7hQghW4i+TiFV/TqAw0XXSZSN+RUAl454XWQTUFQ0XXEFR5dbACJHTn3I+FgiCpn42JDTx4yjppLrFALSEfQGWyh4cJKjj2EAACAASURBVHEV9YoDz3UyokDLDzL9RMPGx8zDkDJF09ZI+mGmj5176g588FVPQq3ixGuwnEJ9bscVSR5jqJp0KU0yIp1T4dKi6YLpY107hfLxMRZNE0LIRlHy45WQnuzeXkXNcygKEUK2FGvtFHoGgAdV9YfWZQ8XketE5Gsi8ow13j6ZYtKen3RK2Gy9goWVyClUN06hNcTHUlEoLbUug9m/WuAUskUgIBspWlz10ai4qDiSHUkfjKZo2rhTyjh9EqdQ3CnkOlJKVDKYqFg0Wn2wTiERgXkaovjY5ItCRU6htGjamj5mPa5kO7s3KO8UykTL2ClECCHrwuR/zJApREQwP9dgfIwQsqUYJD7Wi5cj6xK6H8DpqnpIRJ4I4F9E5DxVXczvKCIXArgQAE4//fQ1LoNMIr4VHzOnZ+se7j+6CiByCs1UPSy3lkvfthF/WrmfpZ1C8bqynUJpfMwmLxI1Ki5cR3Ij6TVzW0YcKWsYGTS2ZZN0CgVRp9CwZc/2mtNOoX73DSs+FpU4TzqCoqLp6GdhfKxLp1DeDUSnECGEEDK9zO9qYD+dQoSQLcTQh24i4gH4BQAfN5epalNVD8WnrwVwO4BHFe2vqhep6j5V3bdnz55hl0EmmKRoOkydQjvqleS0GUk/jFOoIz42ZKeQEZcqXmd8rNMplF1nveqi4jqJWBDEDp2qm/YQGXGkrFg1VHzMdgoFWio6ZmN2y46k731bjkjyGMNpcgrljDyJU8iOj2nv6WN+zp3GomlCCCFkeqFTiBCy1VjL3/OfA+D7qrrfXCAie0TEjU+fBeBsAHesbYlkWjHlz6rAalwmbSZcAbEoVBm8aDoIFcebUfQscQr5IVS1cGz4ILSSrqP+8bGWH2KHtX7jFDL3adZUOH1sA4qmRSRZjx8OLwpJEnkbfB2Ok0axQtWpGEkfdQrli6ajn22/s1Q62ymU7pMXIgM6hQghhJCpZX6ugYPHm8l3V0II2ewMMpL+UgDfAnCOiOwXkdfEV70MnQXTFwC4IR5R/0kAr1PVwpJqsvmxD45NmbQtCtUr0Uj6QYumP3Xtfjzjz78MPwgzziA75lW2UygRcjJF05HTpyg+tmtbNRE8GpXIKWQiaE2rTNuQRrGGFYXKiSsmzhaEmhRPl8V2Cpll91tH1M8TnQ60nMNpXNhrNpjnvWm9jsICwTEj/OTcQLb7iJ1ChBBCyHQxv4sTyAghW4u+nUKq+vIul7+q4LJPAfjU2pdFNgO2QLPcihw+s/VKcpmJjzX9MClG7sV9Cys4stxG0w9zt22XAg/bKTRY0XTVdbCzUcHhpRYa1axTyGxfs5xCRkwZNj5WVhTy4uJrfw2dQmY/1cHFKddy3agq3MnXhOJoX7ei6c7pY/aUObuLqB32iI/RKUTIxMP/pYQQm2Qs/ZEVPGLP9jGvhhBC1p8pqIMl04ofaCKwLDUL4mOxUwjAQBEyIwS1gzDjzliKI2XAMKJQp7vHuIaKRtLXKk4SIatXXHiuZNYV3VZnfKzsyNy0y6fcfl7sFPIDRWXNRdNqdRv12ccSxwYR+CaBYqdQ9NOePhYmnUJhx3YAEOSnj3VxFBFCJgvh+CpCSAF0ChFCthoUhci64Ydhh+hjO4XqFQeNaiSwGCeR4f6FFSystDOXta1yaXsSlO0UKuvMaBUVTVd6O4V2NKLH0Ki48AqcQtWMUyj6WVYcGDS2lcdznaTw2h3SrmPuMrC6mgaKj1mi0DTEx6RgJL0WFE2bbfxu8bGcUyhk0fTAiIgrIteJyL+Pey2EEEIIAJy8ow7XEZZNE0K2DBSFyLrhh4pGJRKFjJtnR6Zo2k2uX21lD6xfcfHV+IvPfT9zmRFdWkGIllUEvGQJSvlJUP1o+52dQuZ0K+jsFKp5LnbUjSjkwHPSTqEip1ASHyvbKTTESHrAdAqFaIcKb8i58GbNqpqIJP1uyrVcN6rR+UnHEfRwCnXGx2whKBMf6+EUygtGpIPfA/C9cS+CEEIIMXiug5N31OkUIoRsGSgKkXUhCKOSYiP6rBQUTdc8J3ESLbezEbA7Dy7hwLFm5jbTmJZmDraN4GSiU2Uo6hSqxWtutnNOoSBE1Ys6hYAoPlZxJVlLs8AplMbHhusUKhvDijqFFMEaOoXS+Njg3UaOY41uV+0rIk0CjkjH78W4fGyhJ5k+VnAZ0OkC4/SxwRCRvQBeCOAD414LIYQQYsOx9ISQrcQUHLqRacQIOI1Y9Flq+RABttVyI+mNKGRFwB46toog1I6pZN07haLt6hV3tJ1COadQsx2g6jnY0fCSx9ZvJH1aNF1qWVanUNn4WDySPhh+JH0yfSzUwUfSWwJLqFo69jYOBNmol1rT1mynUNoppB2XAZ0T7+zr8n1DJMNfA/hDALRTEUIImSjmdzXoFCKEbBkoCpF1wTgkjFNouRWg4jqox+PegUjEOWm2DgC45/Bycvl9R1cBpO4ig90pVDTZrF5xh+8UKpg+1syVX7eCEDXPSeJjUdG0k6ylVRBFM46ZsvExVS0dHQMAz3GskfTDdgrZTqHBxClHUnEsDKdDFIp6kNLz9q+oKD6W6RTqMWGMTqH+iMiLADykqtf22e5CEblGRK45cODABq2OkI3n23ccwplv/A98/4HFcS+FEILIKfTA4mrpWgJCCJlGKAqRdcE4JGwnUNV1UK+kolDNc3D2SdtR9RzcfF/6Rfi++C8zeadQy3YKWQfbS/F2jaoztFPIdveYkfL5TqFmO4ydQl2Kpns4hcrGx4Ih3TZ2p5A7dKdQ9NN2zvQdSW9PH9PpmD4mknMKWZe3gjDjfAKy/UDaQxTKOIUoCnXj6QB+TkTuAvAxAM8SkY/kN1LVi1R1n6ru27Nnz0avkZAN4zM3PQAAuPK2Q2NeCSEEiJxCQah4YHF13EshhJB1h6IQWRfa8QF0PeMUEtTjyV6uI/BcBxXXwWNOnsWN+xeSfY0olB9Tb0qh24FmnEKmU6juuR1Rnr7rLHIKucXTxyKnkJuUZTeqxinUvWjaTeJj5TuFhhGF7E6hoUfSO51OocHiY9HpMBxu7RuNvWYgfazGzWZEPqMF2VEw22GU/yuifbbNoulCVPVNqrpXVc8E8DIAX1bVXx/zsgghhBAAkVMIAHuFCCFbAopCZF0wnT/JSPqWH8XHYpGobrlpzpvfiZvuW0jcF/cvRH+VyY+ptzuF7CLg5WYaHyvtFPJN0XQqYjiOoOo6SXG0IZo+ljqF6l6XkfSZ+NiwopBiGF3F7hQavmg6XcPARdOSRqrCIaNvG43jAApL6DGiUCUrChaOpO8xdt7+XbNTiJDJp6SRkxCyBdi7KxaF2CtECNkCUBQipbnsu/fhoWO97bQmajNTzXUKxQfcNStG9tj5nTi26uPuQ1GvkPkAXm526RQKwow7I4mPxZ1C3aJaTT/AR666Oxn3bm4LyEa+zPm8U6jpR0XTF5y9B7/5jIfj0afMwnMk7RSK15eNj0U/yx506JBOIddx0A4V/kg6hdTqFOp3v5JsG05JfMwRyUwRM78jI1ya11syVa3bSPqcGyjsES0jnajqV1X1ReNeB9mCTP7bFCFkTJxKpxAhZAtBUYiUYrUd4HcvvQ6f+M49Pbcz7gk7Plb1HNTiaE7NEk4eO78TAHDjvVGELOkUageZg++WVejctg62k6LpWIDqdhz+tR8cwFv/5abkfgCrU8jN/leoeQ6afipKqWriFNq1rYq3vPBcVFwHnivJgX+RU8iII2WLpqOy5lK7AEDsXIo6l4bvFDI9SKn40U+gEqu0OQjLT00bByKSEXBSp1AcHzNOoaRo2p5Ilt5O3g2UcQpRFCKEEEKmjnrFxe7tNTqFCCFbAopCpBRGADm01OqzXTySvpKOpK+4khRP26LQo06aRdV1cFMs1pj4WBBqpuy55afxMdspdNyMpI9vs1uv0NGVdrx9Gksr6gECOp1CfhhFqfLikec4nfGxwpH0U9QpNER8zHVSUUVV4U7BO4sjWXHHnE6KxpP4WHq9EYgyI+nz08foFCKEEEKmHo6lJ4RsFabg0I1MEkbcOLrc7rmdid4YUUgV2U4hKz5W9Rycc/IsbrpvASutAIeXWti9vQYgO5be7hTyu3QK2WvMsxiLQksZUch0CnWKQnankBEIapWcKORKZl3RbVn9RENOHwtVkz6iMoymU2i4oukkZjXk5LSNRpD9vZjHaqKNrSB67WWcPwVRsnzRdJhxCrFomhBCSMr9CyuZ7zZkctk712B8jBCyJaAoREqRikK9nUJmO+MMAmJRKHZh1HIdPufP78SN+xeSv8g88sRtALJj6RPxxddMj8uSiY/Fgk03d8biqt9xm0bsqeT6d2o5p1BRNAxAcdG0VxAfK6kN6JBlzaPpFIp+2k6hfnEwM8lLVRGE0yEKObn4mMa/I/MabeaKpoE0FmlrfHkRMisY0SlECCEk5Sfe/WX82geuSs63gxCXXHFnxx8YNjsi8nwR+YGI3CYibyy4/nQR+YqIXCciN4jICzZ6jcYpVPYPe4QQMm1QFCKlMAe8R/o6heL4mCUKVV0HnuvAcyTpFjI87REPw+Kqj49cdTcA4BF7tgPIi0Jp0bSZGmZv0xjUKdTKxscqrnSIHvn4WDMRfLLrtkfStwqiaHYUqwzDxscqcadQECq8NXcKqdUp1Hsf1xpjr4qpKJq2e5CAHp1CmThY52XtHp1CjI8RQsjW5lu3H8KP4kEahv/80dHk9CVX3IW3/dst+HD8/WcrICIugP8N4GcBnAvg5SJybm6ztwL4hKo+AcDLAPz9xq4yGkvf9EMcPN77D6GEEDLtUBQipTAHw/2cQuZguGHFxCpeJBTUK25HDOv555+M+blG8qXokSdGotBKgaunHYSZ0l/TEWSKprv9tc2IQvZUs0gU6vxvUPPc4viYV+QUCjPb2G4iEYHIMKKQDlXW7MadQn4YwhtFfCwcrGja3FUQGqfQUHe9oTi530sSH0u6qTqjYuZ0VvjJvt7sTiEWTRNCyNbkwLEmvnbrAbz8/Vfhgr/4Ssf1B4830Q7C5DtMv1j+JuPJAG5T1TtUtQXgYwBenNtGAeyIT+8EcN8Grg9AJAoBwP4jy322JISQ6YaiEClFaaeQJQoZ50q94nQ4hSqug9c+4+EIQoUI8PDdJj7WWQrdDkK0A01Ej+WkaDoWhbrGx2JRKOc+KhKFqm7eKRTtkx9d7zlOEhFqxa6jfBeQKzJE0fSQ08fiaWhr6xRK1zBo0bSTOIV06D6kjSb/mJKi6Q6nULqNeW1pwWUG87v2HOkQjAghhGx+Dh1v4knv/CJe+cGrk8s+knMC7fvTL+L3PnYd/uGKOwEAf/OlH27oGsfMPAB7jO3++DKbtwH4dRHZD+ByAP9tY5aWMr8rHkvPsmlCyCaHohAphTngXVxt9xQ6unUKAZELJ+8UAoCXPuk0zM1UsGd7DTsaFQDRWHpDKgop/CBE1YuiaGmnUL/4mOkUSoWmVhenUDU3kr7ZzSlkjaRv+8W3FXXXFC6pK2E4XHzMjaehra1TqKBous87ReouikWhaegUcrJOIROVM51Cpmg6LHD+ZHuGckXT8XVVz6FTiBBCtiBHCtzUb/2XmzoKpi+/8YGk75B08HIAl6jqXgAvAPBhEen4NiIiF4rINSJyzYEDB0a6gEQUYtk0IWST4417AWS6CCynxOJKG7u2VQu383PTxwCgGsfHLrzgLJx2QqNjn5mqh7e/+HwcONbETCwmZaNe0W02/TASPRwBPMfqFOpXNF3QKeSHqBaIJ7Xc9LFmQYk0kHWDtGKhKk9efBiEYZ1ClXg9a+sUin5GnULmsj4j6TNCUnp+kpGcWGdO5zuFijqCTESs6jodZdJGI6p6TkffECFk8uD/UrJWrr37CB5YWMW+M3fhpB31rtvRcZJwL4DTrPN748tsXgPg+QCgqt8SkTqA3QAesjdS1YsAXAQA+/btG+l/5x31CmbrHn9vhJBND0UhUgq7L+XIcqurKFRUNG1cNK982pldb//nHncqAOCew1F+O+/qMbdtuoAcR1NRqGqcQiU7hQqEnKrnJPcHFE8WA9KiaVXt2k80XHys/8SvIlxHEMROqrWPpFdrJH3v25Kp7BTKTR+DKZrOTh9TjR6fKhAExikU7VP1nA4R0vQwVV06hQiZZKbgbYpMEDfft4AfHVrGzz72lI7rfvG9Vyanv/+O53e9jf926XXrsrYp5DsAzhaRhyMSg14G4Fdz2/wIwLMBXCIijwFQBzBaK9AAzHMsPSFkC0BRiJQiDG1RqHuvkDlQrnpOXOiLQsGkG0bgWYnjY0Z0ASJ3jx9E8ShX06/1xuHRzZ1hLNrZ6WPFnUI1z0WzbYlCQZhcbuNZU7eaftgxsh7oFB8GQVX7RraK8FxJR9KvVRQKU/Gjnz5lBCgjgkxHp1C2G6iXU6jqRs6xdmiEovT13a1oulbpvI4QQnpBGXlyeeHffhMAcNefvbDndo/+n5/FBY/aU3jd9+5fHPm6phFV9UXk9QA+B8AF8EFVvVlE3g7gGlW9DMAfAHi/iPw+ov8ar9IxzIbfu6uB/RSFCCGbHIpCpBS2U2hhpfsEMiMKeY6DSnxAXUYUSuJjsQsoCNMok3EKeY6TESuMYFPkzvCtCR920XSvTiHbKdSMxamiTqF0TdpxPRAJJGFpp9BwvTxeplNouPiYudsyTiEjCpl+namIjyE3fSzMjqRPpo+pxh1TYdopZLmBuo2kr3kunUKEELIF+fqtwxlalls+Zqpb46u5ql6OqEDavuyPrNO3AHj6Rq8rz/xcA9++4/C4l0EIIesKi6ZJKez+lCNLPZxCsTjgOZKILkXdPd0wk8SMgGMfeLcCRTuMDtRNnMuRtLOoqFPomFXkuNTMTjTr2inUzopH5nIbz3LItPygOD7mSEZMG4Rhe3mikfSmU2g4YcYIPKqpI6bfTZmoW3uqnEK5+JiZPmaKpv3UpWYu8xOhKNq2qEw6tPuGKAoRQkow+e+cJM91Pzoysts6vNT9j21kPMzvauBY08fCSu+pu4QQMs30FYVE5IMi8pCI3GRd9jYRuVdEro//vcC67k0icpuI/EBEnrdeCyfjIcx1CnXDHDx7rqASiy5lnEKOI2hUXKzEUS/btdMOQvhBCM+RJK5VcZ2kWLmoU8iUTAP5kfTFTqFah1OoW9F0Kha0/C5F05Idaz4IoWrfyFYRniNoB1Gvz2g6hbKXdcMIWEYMnIbpYyIC+6USJrGvOD4WZONj5jSQjY+1c9PHzDacPkYIIevIhLy9PrCwOu4lkHVkfm4GACeQEUI2N4McpV+CuP0/x3tU9fHxv8sBQETORVQWd168z9+LiFuwL5lS7IPcoz06hUz3SsV1khhTUaFzL2aqruUUyopC7SCKRxkHRyQKmShX5zdFM45+tuZlRSG/S6dQxUXTD5OYkBEIOoumjTspjPuJOsUQR8rHx1SHHEnvCpqxw2X4TqHopz2Svt9SzD7muZ8Co1DcKWTFx/Ij6a1OIfPaNR1BGTdQl/gYp48RQggh000ylp4TyAghm5i+R+mq+nUAg4ZpXwzgY6raVNU7AdwG4MlrWB+ZMGyn0NEenULmwDjv5ilDo+pipYso5IchKq4kIo3nSkfZsY1xCp0yV++YaFYkVu1sVKCaxs6MQNBZNG3Egu5OIdcpXzQdTfAqr6xUHCdx9wzfKRQ/j6oIw8ix1G8SmomLGdFkWJfSRuKIZP7QbE8UA9LfuSo6nEL22Plu8bGa53SdhEcIIWSNjPBjRlXxpn++Ad/84cG+27aDELcfOJ6cv/ou9s1sZubnYlHoyPKYV0IIIevHWjqFXi8iN8Txsl3xZfMA7rG22R9fRjYJmU4hyyn0tVsP4MPfuis5bxwSUdF09M2tTKcQkHMK+VankJk+5liikONYrp0ip1C01pN3NrCUG0lftK5dM5X4MUbCl3HfdMbH0qLpbqXVjgiCktrAsPExW4xZq1NI4/jYIOJUGh8brJh6EnAc5DqFotNu/LpqmvhYXDQNpK+t0I6P5aePxWdrBePqCSGETB7Hmj4uvfoe/PrF38bdh5bQa8jV2W/5DJ79l1/DvUdXcOuDx/APV9y1cQslG87u7VXUPIdOIULIpmZYUei9AB4B4PEA7gfwl2VvQEQuFJFrROSaAweGm9JANh67MPmo1Sn0T9fcg//3y7cl55OiaVfS+FhJ58pM1UvGx9v9Pq1A0QpCeK6TODiqrvTsFDIFgafsqGOlHSTujm6dQnM5USh1ChXHx4LYKVQ8fQylnUKDijF5bCFozZ1CocZT0AbYJ37YraRTaKi73lBEJNP1ZE4LInebESKDMI0YGtFLLTdQPj5mC0bsFCJk8hnDlGsywfzUX3wVH/rW3bj27iOZ7zl5Lv7GnXjue76+gSsj40BEML+rQVGIELKpGUoUUtUHVTVQ1RDA+5FGxO4FcJq16d74sqLbuEhV96nqvj179gyzDDIGjN4yW/cy08eafogjy63ky3Uykt5Np4+VF4W6xMf8qGg6Gx9zEhGksFMojo+dtLMOAFhpp1PNikWhKoC0N6nphxDpdN8YwasdC1XFRdPl42OqmggtZbAjY0X9RoOQFk1H//pFx+x9jEAyHfGx4k6haJKdg1Zgpo+lYqCJxyXxsYIJY0mnUEHfECFkchjkvW2j4TvGZHDt3Ufwi++9Ek/7sy8DSP/QZfPBK+7c6GWRMTE/12DRNCFkUzOUKCQip1hnXwLATCa7DMDLRKQmIg8HcDaAq9e2RDJJGKfQnu21zHjOph8VLS/FIo45GK5Y8bFRFk37sXujGnf8RI6kHp1CKz4cAfbM1gAAy820K6hIFNplRKGV1ClUdZ2Ogwh7JH0315ErUtoxEjl01uoUGrJTyEnXoIM6hXLTxybxYCuPIO8UMqXakVMoKZq24mNBQXwsf7BgF0377BQihJCpxXwHOcRR8VuavXQKEUI2OYOMpL8UwLcAnCMi+0XkNQD+l4jcKCI3AHgmgN8HAFW9GcAnANwC4LMAfkdVgy43TaYQM0XrYdurmZH0zdh5cyT+4uSHkbPGcSynUEn3SKPqWY6etMA4mT7mpPGxipNOHyvsFFptY0ejgu21SERassSmqtejU2gpdQoVRcMynUKxcJTHGaJoelCHTp7RdApF+6kOLk4lLq1wupxC2U6h9HLPlUx/kPm9msuMw8grcAqZPijPZXyMEFKOyX/nnB5UFR/99o8ywyUIGYb5uQYOHm9htc1DGkLI5sTrt4Gqvrzg4ot7bP9OAO9cy6LI5GIOgE/YVsVyK0DTD1DzovHtAHB4qYXTTpiJYlmOKYGOnUJl42MVN/ky14r7XbZVXbQC7YiPVbzenUKLK23sbFQwU41e8uZ2u7l7ZusViKS9SU0/TFxJNrY7qd1lkpkjaexuUEJVDJP+8lzbKbTWkfSDF02bffxp6xSyRJs0PibwHIEfRE4pVRQ4haLnt+JIhxsoCBWumOsoChFCyDAsrrZx/9FVnHPybOl9Dx5v4ncvvQ5X3n4IN923gHe95LHrsEKyVbDH0j9iz/Yxr4YQQkbPWqaPkS1IkDiFohiW3bkDAIdjEcUPwkSgSIWb8iPp8/GxbTUviY95rpO4dzwn7RQq6nFZXPWxo17BtkQU6t0p5DqCnY1KMmGtW4l0OpI+xEorQL1AOHJEMgXdg6BDF02na/RG0ik02BQ0s097mqaPicD+tSROISd1+dhRMCAVRYM4Vue50vF6C1ThOALXcRCwU4gQQobi197/bTzvrwcvcv7qDx7CL7/vSgSh4vc/fj2uvP0QAODwcUa/yNqYn5sBAOxnrxAhZJPS1ylEiI1xU+y2RKGTdtSTke3GWeOHmog0xik0zEj6fNH0TNWNRKFAUbFG0lesTqEid8bCShs7Gh5mTHysmU416+Zg2jVTxdEVI3oFPeNjTT/EUivAbL3zv5TrZB0pgzCKTiFv2E4hyyk0qDiVCHJhmDk/yTiSLXW1O4W82AFkfm3mNWJcaJFYFgk/+WLzMHYK2RE0Qggh5bjx3oVS2//upddhcdXH8VUfx5vTGRnjILzJJHEKURQihGxS6BQipUicQtuiImbTK9Rsm/hYJKL4YdgxdWyY6WN+POo94xTyQ/hh5EQyXS8Zp1Bh0XS7wymkqnEPULGAsbNRSUSull88WcxM+1qIHUVFotAw08eCcDCHTh5bjFnrSHrVEiPpE6dQmDk/yeS7nszLxhGBG8fH7EJpIHVCqUYF4hW3KD4WPfduQbSMEELIcISh4qHF1eT8sdXpFH7I9HHSbA2uI7j36PK4l0IIIesCRSFSCiMK7Whku3lMfCwpmg407RLyhhWF0vtoxQfjM1UXLeMUch1rJL0kHUZBwejYxdVIFJqppk4hIx51dwpVEtGrFXSJj8WC0pFeopAjKJsiGjo+ZglcoxlJP5hjyXFy8bEpcApJR9F0OpLei/uA7PHyQPr6D8I4PlYQETNCmsdOIUJISfiO0UnTD9DyQ7zni7fiye/6Eh5YWO2/EyEjxHMdnLyjTqcQIWTTwvgYKYU5KDaCzWrsEDLxscNWfCw/dWwYpxAQuXrasei0reolo8JtUajqOnB7xMcWV/woPmbfZiwedes62jVTxa0PHo8eX7uLU8gxolD0uGfrlY5tHEkFh0EJVUtPa4vWk65xVEXTg0xBS4umNXN+kokcXOl52ylkOoWMaFTLdQoZscxzBe2iounYKaQa/XV7GkQyQsj4mAJz5dg4562fxc5GBXvjCM+N9y7gr77wg5Hc9nLLx20PHceZu7eN5PbI5mWeY+kJIZsYikKkFKYweVsiCkVikBFqjlpF025ODCoa/d6LRoGAExVNxyO/HSs+5krXkfQtP8RKO8DORgXbatG6l1o+2n5vp9DOmQoW4k6hVhCiUSmYPhaLMMYhVdgpJFJ6NPmwnULZkfTDdgqlTiEdMD7m3CdZCAAAIABJREFUSq5TaAqOcPJiXdophCT6ZfSeZPpY/DpURfIaLCqadh1JXld+qKhSFCKE9IBdMr1ZWGknn8e/84//iVaBI9jGfsfVLv6rpaaPN3z8enzhlgfxjT985qiWSjYpe+cauOqOQ+NeBiGErAsUhUgpTGHytriwebUdQlUzI+kBoB1qEmXyhu4Uil6eKxlRKCqaNm6OND6WdgrlBZhjqybaVUHNc+BIdJvmS2W3TqFdM1Ucb/po+SGafiQq5TGP8XAvp5AzjCg0mEOnYz0j6BQCUsEkDAeLsUnSKaSZ85OMIO8Uyo6kb/lhcpkt8JhtXSd6DfphNLo+EdNCTXqJgM7XIyFkMpjEd6lJXNOk0U8QGoRPXrsf//c/fXekt0k2N/O7GnhgcRXtHgNKCCFkWuG7GimFn4hCqVPI/jJ1xBRNB2HS8WNEl+HjY3ankBeVTwchKq41fcxJO4Xyzg1TRjlb9yAi2Fb1sNS04mM9OoUA4OhKKy6k7h4fO9qzaLr8X4EHdeh0rGcEnUJAWo49aNG0EUDMczot08eynULm8lTsMc64xCmU6RRK3Wm28GPiY6lzjQcbhBAySXz5+w9mzk/+JxYZN/NzDYQKdloRQjYlFIVIKcxBdCIK+UHiEgJSx0wwAqdQEh9rW06hahrh8hwnEWoqrgPHEYikY8MNZjStcfHM1Fwst/y+otDcTDRh7ehyGy0/RK1SJArF8bHlHvExRxJxYVDCYYumR9ApBKR9O4M6lsxT6Cei0NB3vWGIRJ0/JkJmx8e82N1lnHHVDqdQPLq+oMcq0KxTKC9SEkIIWV+mwa1KpotkLD17hQghm5ApOHQjk0RSNF1J42NmHP1szcPR5RZUFW17+pjpFBrSKbRiFU3P1FLRxbOcQkZ48hxBuyM+FolC2+N9Z6oelgYomp4zTqHlNprdnEJuzilUKyqanq5OISCdzKVxTKr/9tMXHzPPr9Hr0qLp6HlsB2FymXmN+MlIeoXrIHWnWb/fsMMpRFGIEEIImWbm52JRiBPICCGbEIpCpBRG3HBdQc1z0GwHyeSxk3fW0Q4Ux5s+/DC0HEJmNH05oWBbMpI+iHuEgLol4FRd2ykU3bZb0N+TdgoZUcjFctNHyzcukO6dQgBweKmJY6t+IlLZmAP/w0steI6gXuAmckSGmD423AQvOzLmrTE+porB42NTWjQNpCOgU6eQJE6hJD7mmphYGP/Mu4FSd1qgSPqGzLaEkMnlGz88iEuuuHPcyyDrxDAl3nzXJnlOnaNTiBCyeaEoREphDpxdEdQrLlbbaXzs5J11AFGvUJFTaOj4WNwpVHGdjKsn4xRyTLeQ0xHXMfEx4xTaVvWi6WN942OR6+cbPzyI400fP37Gro5tzIH/wko76SzKM0x8TEfiFFpb0XQY6sAxNrNNOpJ+CkQhx0xZS90/QG4kfZheVnElEx8zlwGpQwowRdPp74KdQoRMPm/7t1vGvQQAFCMmFU6HI/WKiz2zNTqFCCGbEopCpBTmoNiNXTEr7SCJj528IxKFDi+3EITaIQaVFYWMiHO8GQk4tjMIQGb6mHEhua706BSKnUI1NzPmvl+n0OU33g8R4CcfubtjG9uNUzR5DDDxsT4PNkcQKoZJf42+U0gxiL5j7taII2tIrm0Y5nEZUci8bBwzaj7UzEQy24WmGv1+itxA+aJpOoUImUz4P3PzMvl/liDTyPxcg04hQsimZAoO3cgkYTsnIqdQmMTHTjFOoeUW/CBMRIkfP30OP33OnkTkGZSa56DiCo6tRqJQxUtFICCaOJZOH0s7hfIdLkmnUD11Ci3bI+m7dAptq7qouIIjy22cf+pOPGx7rWMb241TVDINpOPdyxBaI87LMPpOoZJOoVhZmQqnUK5TSK3LXUfgB2Eal3QEnuMkr618mXQ7Ex/LX8dDT0LIYEz+O+fmZBp68Mj4md9FUYgQsjkpd5ROtjzm2NdzBHUvGx87KYmPtdAONInWPOWsh+EpZz2s9H2JCGbrFRxbbcfOI8m4ejzLOeRZnUJFI+mrroOaF8XRTKeQOVjv5hQSEczNVHHgWBMXPKrTJRQ9D+m+3UShop6jfgwqxuQZVaeQ60Q9SIMWXk/jSHqzwsQpZE0fM1GxxCnkZJ1C+fhYcdE0O4UIIYSQzcLeuQa+cMuDUUx8Cr7nEELIoNApREoRWAfJ9aqLVT9EKxaFjFPo8FIrKpoeQYZotu7h2GpUCl1xnYyAU4nLrqPTabdQ3il0vNlOXEIAsK0WTx+L191rKtpcI4qEXXD2nsLrs06h7vGxcAin0DDfN0bXKVQyPpabPjZNTiHzctGCqJg9kSxyoYXxPhqPrjfCT9Yp5DrCTiFCJpzJf5faWhw41sTXbj0w7mUQ0pX5XQ20/BAHl5rjXgohhIwUikKkFEGYxsLqnpNxCu3eXoPrSBQfC3VNThXD9pqXxMeqrpNxwlSsTiEjgHhFnUKrfia61qi6WGpaRdM9pqLtmqlie80rLJkGInHMaC+zXeJxjiMoaxYZtOA5z6g6hUSicuwgHDQ+Fv00U7im4Q9oHZ1CiQCURsWS+FgSKbNG0kvaG2RHxMxkskoysYxOIUII6cdLL/oWXvnBq0dyW/bHFt+ByajgWHpCyGaF8TFSiiBMx43XKy6OLreSTqF6xcWumQqOLLfhW9PH1sJs3cPxOP5VyRdN251C8eVuQafQ8aafiXbtmqnADxWHllqZfYv4pX17sbDc7rmN5zhoBWH3+JiUFwYGdeh0rCUTHxte8zU9SKZQuR9JfMzq4Jl0kk6hWENMS6WRdArlx9QnnUKx8GOeYzuyGHY4hXhIQshmJAwVfqhde+lIf1p+CIWi5rm448DScDeiwJlv/I/RLoyQAuZ3RaLQ/iMreMLpxX8sJISQaYTfZEgpzAEvANQrTlQ0HU8fq3kO9szWcd/RFfhBuCZRwjBbr2BxtR0XTUtmJH3FdTDXqGLPbA1n7p4BEEd8CjqFbKfQqfFfeu4+FH0B7RUf+5V9p+E3Lzir5xqNEDPK+JhqKr6VwRtlfCzEwJ1C6Uj6aSqajn4qsk4hEYFnOoViwch10jH1ZluR9HdvR8SC0LiI2ClEyGbmDR+/Ho9662dGeptb7d3iaX/2JZzz1s+u6TbKfr4SMiyJU4hl04SQTQadQqQUZtw2EDmDVv00PlbzXDzmlFl8/daDSVnvWkk6hYKw0ynkChpVF995y3OSy9yCTqFjqz5Onasn540odNehZQC9nUKDYMSXrtPHHEmmtg3KoGJMHtuhs7aR9NEaIvFjAFHIuGKmqVPI6dYpFP1Og1CTDi3XyU62U82Onc8WTQOO01m+TQjZXFz23ftGdltT8Ja5Lhw83hr3EgCwX4oMxmy9gh11j/ExQsimg04hUoooNhOdTqePRfGxmufgsfM7cfB4E4eXWiOJEO2Ip4+1Y1EoM32sINdUKeoUauacQjsjUehHiSi0tnUaR1Q3p5Ab9/OUIRwwttWxFicbrxsWsYqmB7kZ42qapviYEbvy08eioulsp5Ak5dPRayuJj8XPd34kfeQsYqdQL0SkLiJXi8h3ReRmEfmTca+JkHFBs8toEco8ZJ2Y3zVDpxAhZNNBUYiUIusUiuNjxilUiUQhs90opo9tr3k43vTR8qOi6apVCl0k5nTvFEoFmz2zNXiO4O7DUXysssY+iP5OIZQumg7CwRw6HWtxR+QUckynULmiaTPRbQo0oWSNiSgU6zoiQCXn8skXTUdF4Cgsk04FI3YK9aEJ4Fmq+jgAjwfwfBF56pjXRMhYmYK3zk3JVnVqkfLMzzXoFCKEbDooCpFSRC6I6GVTr8ROoXY62v3cU3ckB9ujio+FChxdaaPiStYpVBD7KuoUOr7qZ0bSu47g5J11rLb7j6QfBHPwv72bKCTl42O6xpH0niNDiUoG04M0qFMoiY/FyoozBapQUjQd/2oyTqH4tduKRS7j/Ek7hRSOXSZdUDSddAoFFIWK0Ijj8dlK/I9PFiGkFPk3Dc1dUuTCyl9GZxEZlL27Grj36EoSOSeEkM0ARSFSijBUGA2lVnHR9EOstAN4cRHvTNXDI/ZsB7C26VcG4/A5vNTqiI91cwrZro3VdoBWEGbiY0AaIYtuZ42iULz/jm7Tx5wh42NrKJpea3zLseJjA3UKmfjYFHUKmRUaMcj8ikRgjZoPk8tcx0niccZBZV47mfhYXDTN6WP9ERFXRK4H8BCAL6jqt8e9JkLIdPPQsea4l0A2MfNzDRxv+lhc8ce9FEIIGRl9j4ZF5IMi8pCI3GRd9hci8n0RuUFEPi0ic/HlZ4rIiohcH/9733ounmw85oAXABoVFwCwuNpGzYpgnR9HyEY1kh4AFlbaqHh5UaioU8jJTII63vQzt2MwxdNm/PhaSONjPaaPlS6aHk5YMY9lrUKXWEXTZTqFzHM/zOS0jcZJOoUQ/8x2CgGWUyiOg2U7hVDYGxSEkYuoaDIZyaKqgao+HsBeAE8WkfPt60XkQhG5RkSuOXDgwHgWSQiZKp77nq8zh0fWjWQs/dHlMa+EEEJGxyBHjpcAeH7usi8AOF9VfwzArQDeZF13u6o+Pv73utEsk0wK5oAXiDqFAGBxpY1aLBABtig0CqdQJOaoRjGvzPSxArUi7xQ6vhqJQh1OoXgC2VrFE8AeSd8jPlbSLBI5dMqvRWLxYhROIVUTY+t/WxI/jSZGNQWaULLGMImERecjB1B0ZdOOj2U6hTR5roG0YNtcZzuFWDTdH1U9CuAryH3WqOpFqrpPVfft2bNnPIsjm5ZpeJ8i/VmPXyOjQaQbyVh69goRQjYRfY+IVfXrAA7nLvu8qhrf5FWI/spLtgBmshIQdQoBkYvHFmtM2bQ3ok4hQ8UVVL3eTiF7bDhgO4WyLp5T4g/1tfYJAUhcJd2dQuWFgUELnovXI2t2aTkZp1D/20qmjwWpiDLp5DuFTA+F7R5rJfGxbKeQqnEPRb97Px8fcwSV5DoeXBQhInssl2kDwM8A+P54V0XIeOG7xWSS7ykiWxfjFOIEMkLIZmIUnUKvBvAZ6/zDReQ6EfmaiDyj206MBUwn+eljgHEKpS+l807dgbmZSvLXlLVgCy1Rp1AqNhSJTvaEKCCKtgGdTqH5OD621slj0boEIsC2qlt4vetIEk0alNAS38oyKqeQKZoeRJvK9+dMhSgU/+rNl32j29kOILto2oypByJx1HHS12C2aDoq2nY5kr4fpwD4iojcAOA7iDqF/n3MayJkLNC1RMh08LBtVdQrDp1ChJBNRXHeZUBE5C0AfAD/GF90P4DTVfWQiDwRwL+IyHmqupjfV1UvAnARAOzbt49HTVOCicYAQN1LnUJ2p9C2modvv/nZI3HhZJ1CDlwnEmBUi+NpXr5TaLVbp5CJj639m7jnCLbXvK6FzM6QotCwBwlerpB7GCQpmh7MKWQ2MSPpp+EAJ98ppJo6hbxcp5ATl09npo9ZRdOtjqJpcCR9H1T1BgBPGPc6CJkEmFYaLdmPoM4nN/8ZNQ2fWWQyEBGcOtegU4gQsqkYWhQSkVcBeBGAZ2t8NKWqTQDN+PS1InI7gEcBuGbtSyWTgB8Ux8f27prJbFfzil0zZbGdQlXPgcQH4i0/LBSdzIH7P11zDw4ttXDibA1Ap1PolJ0j7BRyHOzoEh0DTBSr3G0OWzQdrWcUTqFIJNEBR9In8THjFJqCb9iSiEKx0BOmRdPGAWTEHifuCPKt/iFHJPm9G0cakPZupZ1CLJomhAzG5L9zrj864NRLQsbF3l0zFIUIIZuKoY6IReT5AP4QwM+p6rJ1+R4RcePTZwE4G8Ado1gomQzsUekmMra46mecQqNkW9VNRAnj6jFiUNf4WKj44BV34b1fvR3HujiFdtQ9bK95I3Ezea50LZkGIoGkfKfQYGJM4f2NpFMoHUk/iDhltvEtEWXSMU+RcQjZRdNuQXwsKpqOzofx9LFG1UW94uDocioKGTddOtaeFgBCCCFkszA/12B8jBCyqejrFBKRSwH8NIDdIrIfwB8jmjZWA/CF+K85V8WTxi4A8HYRaQMIAbxOVQ8X3jCZSoJQEzHGOIWCUDOdQqNEJIpmLa76iavHiENFopDnCJZbAR5YWIUfKr53f5Rc3J4TbSL7bx0ygr/Lnj+/Mym0LsJMawutyW39iEaeD7e2iuusueQ7KZoOMdBfbM3jMt06gz7OcWJ+9/mR9OKgo1PICEX5+BgAnDBTxeGlVnK7pneL08cIIYSQzcfeXQ0cWmphpRWg0aVPkhBCpom+opCqvrzg4ou7bPspAJ9a66LI5BJYsaaGNYZ+VHGxImbrlZwoFP/s0ilkH6B/645DqLpO4frO2r0dh5dbHZeX5c0veEzP6x0rpuQMKEKFOpgYU4QpRV4LknEKDbaPI0A7TDt4Jh2zRiMGqeUUSjqFkmlq0evOjo+Z38/cTBVHcqKQ46R9Q+wUIoSQjWUKzKpkiknG0h9dwSNP3D7m1RBCyNpZU9E02XoEYdjRKQRg3eJjQBr9qlqikCPFbpR8bOruQ8s4YVu18Hbf+ZLzN+SAPXGMqA70H84uPB4Gb0Qj6aNOocEnidmT3/5/9t48zJGzPPe+36qS1Oq9Z/WMZsbjFbCNsc1gOOwBE9Zjc0gg+JCQ5CNxSCAfJPk4xx+BkEAIHDiQBOIAxhCWGHzMYmzwBjbe9/HYnhmPZ8zs0z090z29b1rrPX9UvaUqdalbUkuqKun+XddcI5VK0qOtWu+t+7mfKEwfczKF7Mgf0/W8q8lh5ZxCUkqozsNVXXGPuFiw28eYKUQIIYS0Hu6x9BSFCCGtQONW8qQlsSYreUfSA80RhVTbWMLQYJTJAlIL8f7OGM7f2Atgcci0YnV3Aut7O+pd7iLUL5aVagPubJtacLcu1Yp7JH2ldWiiGMQcpUwhsyRTSMA1kt6VkWRowpls527vG+ha7BTSNeF8TugUIiSc1KN9uN4EebTYevWt+Pd79wdYQWPgZDdSb5RTaHBifpk9CSEkGlAUIlVhmkXhpcNoXvsYAMSMolOoXEC0Wsy/ONWHF6f67OsHa4jTXe1jlWCu1Cmka46AViuaEDBNq5ZK9R23EBQNUchbo5Mp5DOSXglt/plCMUy4g6ZtwUjTBDRRzFkihJByhOWQ+YU79gVdQl0Io+BHWof1vR0wNMGwaUJIy0BRiFRFQS4eSQ+gYUHTgNspZItChigbpKwcROdv7MP5tihUzinULNztY5VQFCeCG0kv7KBpKSsXeNz3GYX2MRW7VMwUWjySPqPax9T0MbOYP6Q5rrQ4phZyzmSygiyGsRuaRqcQIWRZ/P48DE8t4InDnNXRDMIiyrWTq0kI8RYhxD4hxH4hxNVl9nmPEGKPEOJZIcQPml1jOXRN4LS+Do6lJ4S0DMwUIlVRcE3QcreMNbJ9TIk67kwho0yQstsppHq+g3YKFbNrKvu2p74U1iqsdMQ0j2BXCyofqJqgafeX6ghoQsXXxZk+Zv2vieJzn8ubrm2a4/opuJ4XlVk1uZDDmu4ETLMopBm6YKYQIaRi3IfO3/rf9yKdM3H4828PrJ5W4O69I4u2lYovtf4IQ2pDCKEDuAbAmwAMAnhCCHGLlHKPa59zYE07fpWUckIIsS6Yav3hWHpCSCtBUYhUhZUpZJ3WNIG4oSGbNxFvaKaQ3T7mEoXKtUfpLlFoXW8ChiaCdwo52TWV7b/S9rFP/dfz6zCSXsCUJswanEJCROMLtlbS1me6nUIlmUK67R5SmULu9rEBWxSamMtiTXfCdtNZ96G73EWEEFIN6RwFZdKyXApgv5TyIAAIIW4AcAWAPa59/hTANVLKCQCQUi5W9wIkNZDEIwfGgi6DEELqAkUhUhUqRFfRYYtCjc0U8gZNx3WtrOjxunPXYmw2i82rkhBC4EO/dbaTLRQUxSlUlbaPWf/XmstzQR0erxCWG6ZgyooFHlVvFPKEgKLoJmWxJQzwzxQStlDkZAq53ECrOm1RyM4VcoexG5rA7qEpfPvBQ3jV2WvwgtN6Gv/ACCGkzan2z5Bsp76tcJACcMx1fhDAy0v2ORcAhBAPAdAB/L2U8o7mlLc8m/qTODmdRq5gOj9aEkJIVOFRjFSFKb2iUDJuiUGNbB/rVaKQEzQtECvTPnbxlgF85p0XOELGX73pXFx23vqG1VYJqpZKv3Qq4SFIt43lFLJqrtSxpEQSPSKikAoiVSKctEO1hStTyB007c4UcrfVDXRZTrbxuazTIqhaLDev6sQThyfw6V/swVNHJ5ryuAgh0WB4agEv++xdOHRqLuhSSAmUiEKBAeAcAK8HcCWAbwoh+kt3EkJcJYTYLoTYPjo62rTiUgNJmBI4MZVu2n0SQkijoFOIVMUip1Cs8aKQah9TmUJ9yVjgOUHVUG3QtFxh+1g90IRVR3XtY/Z1IyI1OyPpHaHHJWzZF2Zc7WO6pkFK6zPgaR9znEJZ5zVWwthP/vyVmM8UAAAd8Yg8MYSQpvCLZ4YxOpPB9Y8ecbZRjAgJJS8EjUR1ZwjAZtf5TfY2N4MAHpNS5gAcEkI8D0skesK9k5TyWgDXAsC2bdua9kql+jutIicWsHlVZ7PulhBCGgJXKaQqCqb0iARqLH1ihcHGS1E6fezjb3sRvnLlxQ27v3qjBALlAErnCvh/vvMEDozO+u6/0vaxemA5hWzxo8KjRNTaxxYHTRfdP7HS9jENjnsoV7CzluznRYlC43NZ5zVWTqGYrqGvM4a+zlhDWywJIdEmIofNlmU5Zy41obrzBIBzhBBnCCHiAN4L4JaSfX4GyyUEIcQaWO1kB5tZ5FKoYSacQEYIaQUoCpGqKMhSp5D1FmqkU+gVZ67GB193Fi7cZGXlrOvtwOmruxp2f/VGfddUvzQeGZvHr/eO4Omjk777rzRouh4IIWCalmBSbaZQVNrHSjOF3I9Vd9rHLJePLoSTaZU3pd1WZ51PxnUkYzom57POa1fr5DhCCGl36uHKqfbPEI/YzUVKmQfwYQB3AngOwI1SymeFEJ8WQlxu73YngDEhxB4A9wD4mJQyNMnOG/o6AIATyAghLUF0enBIKChtH0s47WONc0F0JQxc/dYXNuz2G01p0PR8Ng8AziQrxeR8FkBRFAo2U8iqo6pMIVsXjIgm5Lh51PrD/VgXTR/ThBM+nS+Yixxzq7riGJ/LOa9xVIQxQtqZMH1M2Z5UX6L6fIbpPdlopJS3AbitZNvfuU5LAH9t/wsdHTEda3sSGJqcD7oUQghZMXQKkaowXZOVgOZkCkUdJR6ovJmFrOU+KR1V/v/9aCc+9uOdzpfZoNvHpPSOXl8O9b6IikvGyRRyjaQvzRTK5ZVAV5x+lyuorKXibQ10xTAxn4XS+bSIPAeEkHDBIwch0SHVn2T7GCGkJeBKnlRF3mckPQAkYnwrlcNxpEjlFLJFoYJXFBqby2Bizt2C1MQiS9A02JlClYtT0c8UKtbuZAq5gqYN+wXJm6adtVR8nAOdcStTyAmabspDIIQQQkhApAaSbB8jhLQEXMmTqihdDHc0oX0s6hSDpq3z8zl/p1A2byJnSkekCLJ9TLiCpistQ70vouKS0RxRqOgUUpWrTKGM/VqpkfSAJeaZJe1jA51xTM4Xg6aj4pYihIQLU0r80X88jocPnAq6lEgTkd8mSMTZNJDE8cm0M8WUEEKiCkUhUhUFUzqLY6A5QdNRRz1dTqZQJm+f92YK5QomCqbpfLkIQ/uYrGYkfcSCplWVysElZXEhod7juUIx3yluv8ed6WOuh2llChVdXlERxggh4WJyPod7943iwz94KrAa3vHVBxZtu3XnML55f2gGP7UsUc1Calc29SeRLZg4NZsJuhRCCFkRXMmTqigN2E0qpxDbx8qiBAKzpH0sV1jsFMoXpCtTqHk1lqKCps0qgqbV2yIqeojjFLK1ObcLzh00rTvblCgkfdvHptN5Z4R9VIQxQki4kCEYfr57aHrRtg/9YAc+e9tzDbvPr993wDn97PHF909IGFFj6QeZK0QIiThcyZOqMCVKRtJbolA8yACckKOXtCkt2C1JhRK7ca4gkTelk0sTtFPIrDZoOmLtY+phLRU0DRRFLsMJmjYXOagGumIA4PxaGJXngBDSeA6MzmLr1bfi2eNTZfcpPczKEsvIyHQaN24/1ojyQsHnb9/rnP7Yj59p+P1Rtyf1INXfCYBj6Qkh0YcreVIVedP0H0kfY6ZQOdSodqUBFUfSe7/0Z/Im8gXTNZK+aSUuQohi0HSl2UZRC5ouZgrB+V+9tYUQRZFLhU/bopAS7jzTxzrjAIBTs1kAdAoRQorc+ewJAMDbv/IgPnLD0m1hosz8sT/6jyfwP368k20qFVLueSy7Pw/ZpAYcpxBFIUJIxKEoRKrCNL2LfmYKLY8zkt70to/lC4szhfKmdH4hDtopZGUKVd4+ptwxUQlZ1py3rDtTqFi7XvJ4VPuYEu7cr09f0nIKTcxnPdchhBA3Nz993DntbhVbLktm1BaDGGhLSHjoThjoS8YwNDkfdCmEELIiuJInVVGQ3qDp8zb04gXre9DbEQuwqnCjl2QKLWT928eyeRMF1/SxYEWh6kfSqzHsUdFDSp1CpQJYrMQpVGwfk4vax3o6DADA1HzOuk5UngRC2piwfErdh1h1esI+ljSa6x44iBd+8vam3FeYKBXhqnUWEaJI9XMsPSEk+hhBF0Cig5TSCpp2LXhf/4J1eP0L1gVYVfgpBhovHTSdK5hOiLF1vSYWWYLmGklfsVMocu1j1v9+mUKAKyPJ3hSzc7OytsPLKwpZoujUgrWQY/sYIaQWmn3k+MdbGxceTUg7kBpI4sjYXNBlEELIiqBTiFSMclRwwVsdTvtYyfQx90h607RDpk3TmYZVaZZPIxBCoGAubqlaiqi1jwnfTKFi7YYtAqnHo0ShjB0U7n6YvbZTaHJBtY+UB1VtAAAgAElEQVQ1rm5CCCFLw68ppFkop1BpODwhhESJipYuQohvCyFGhBC7XdtWCSF+JYT4jf3/gL1dCCG+IoTYL4TYKYS4pFHFk9oZmU7jm/cfrOqPmGp34oK3OhxHii32LOQWB00r90ne5RQKUlxR7WPW6UqDpq3/gxSzqkE9LulyCrlLN0rbx+zzGXvsvNsxp5xCk6p9LCLPASGk8TRirXhwdBZ37TlZ/xtuUxZNfwMX+KQyNg0kMZctOE5hQgiJIpUu778D4C0l264GcLeU8hwAd9vnAeCtAM6x/10F4GsrL5PUm9t3n8Bnb3vOmZZUCUWxgqpQNZRmCs1lVNC0jyhkSmcBEXT7mArCrlQELAYzN6qq+qKeXvW6lOYEOaJQiVMom1/cPtYR06Brotg+FhG3FCEkeCxHZoX72v+/4Uv34U++t71hNUWJZsg3dIGQcqT6OYGMEBJ9Klq+SSnvBzBesvkKAN+1T38XwDtd278nLR4F0C+E2FCPYkn9SOdUro25zJ5F6BSqDSUqFEqCpt1OoVxeiUJm1Q6dRqCJ4uvd8iPp7Y9AaX6SbgdLq3ZJFTTtOIU84bACPR2GIwoxaJoQshzVhBvziNJY+PySWlFj6YcmKQoRQqLLSpb366WUw/bpEwDW26dTAI659hu0t5EQoRa2+ULlv34pESMqi/6wsCho2mkfKwpyKnQ6b0pHPAryaRZCVP16R00UUmUWg6ZLnULW4dEJmtaUU0hlCnkfZ0+H4bSPMXeLEFINjhFlmWPHG790H+az+cYXRAKBbWvRQzmFOIGMEBJl6jJ9TEophRBV/SUTQlwFq70MW7ZsqUcZpAoy9sI2Z1buFDLN4LNuoogSCJQxyM8ppFqSpCwKdcE6hYTjFKr05dYjFjSt3DxqMWZK6fm5uLR9TDmFnOljJY+zJxHD4MQ8gOg8B4SQcLHckWM2k8dzwzNNqaXemKaV25bOmciZJubtVmpCosyqrjg6YhqdQoSQSLMSp9BJ1RZm/z9ibx8CsNm13yZ7mwcp5bVSym1Sym1r165dQRmkFjK56p1ChRAEIEcRFcFUKBlJX/DJFAKKLX1BikK6Vr0zTL0tovL2UHWqX2Zl2ZH05TKFvLfX02FgOp33XIcQEh32j1hiy+6hKcxl6MapJ/mCiTM/fhs+f/tevOYL9+DCv/8lDozOBl0WIStGCOFMICOEkKiyElHoFgB/aJ/+QwA3u7a/355C9goAU642MxISVPtYNZlCdArVhtM+JiWklFjIKadQ8blXQoP7dNBB04pK9Y2otY9pJQ4u0/Q+58oZVBxJX5opVNo+FnNO8zNCSPS47Mv3Yz6bxzu++iD+4voddbvdakKKI3L4rBr1I8N3Hj6MU7OZgKshpL6kBjrpFCKERJqK2seEED8E8HoAa4QQgwA+BeDzAG4UQnwAwBEA77F3vw3A2wDsBzAP4I/rXDOpA6p9zN3CtByOU6hVv7U2CPf0sXTOdNqVPEHTLnFOuYaCHO3uvu/2yRSSS2YKGbZTyG8kPWA5hRQMYyckAvgcqmZst99TRycWXTY+l4WUEqu7E3W5e+bHNI4g/36S9iPVn8TuoamgyyCEkJqpSBSSUl5Z5qI3+uwrAXxoJUWRxlMMmq7cKeRk3dAFURXq6SqY0hMQWjCXax9rTn1+uO+7ZTOFSp1C0ruQMErax9T5pdrHSm+bELJy7tpzEmes7cJZa7sbfl+f/sUez/mhyQUnSPaSz/wKAHD482+v630263Dxy2dP4Kx13U15HglpJzYNJDE+l8V8No/OeF3iWgkhpKnw9+w2RY2kz1bTPkanUE0ogUDKYp4Q4HUH5Xzax4IUV9yiRqUioLpKVN4exddFiXMlI+lLRK6Y4xQqP32s9LqEkJXzJ9/bjjd+6b663NbxyQW86JN3YOvVt+LAyOJMm1Mzxdamm58ewqs+/2s8vP9U1feTzhWqas9e7rhZj+PqVd9/sm7PIyGkyCZ7LP1xtpARQiIKRaE2pZaR9MrZorJWSGUogcByChVFIbdTKOPjFArS/u7WNCqtI2pOIVWlyspaNJJe9zqFdE1AiOJnp1QcdWcK0SlESDj56q/3O7luD/xmabHnqaOTAIC9J2YwMpOu6n5e+Mk78OZ/vr+2IsmKqfoIzEM2WQHKTTjIsGlCSEShKNSmONPHqhlJL4MflR5F1PNVkN72sZxLkPNzCgWprXgzhSq7jhJJouIkW9w+5nUKOZlCrqNkTNOc16f0YdIpREi4mcvkMTxVXLT5/STiFu7dXPrZu6u+v4On5qz7qeC3F7WPiIg6ce4nbscHv/9k0GXUjag87yScpGynEMOmCSFRhY2vbYpqgclV4RTKc/pYTaj2KyklFuwFR2dcL5spVG66VTPxtI9VWIcSkqIS8ClssacYNO2fKeQWuWK6KPv6dCcoChESNkZnMljbYwVDv/vrj2DP8PSS++8KOCw2IodPZPMm7nj2RNBl1EypUBeV552Ek3U9HTA0QacQISSy0CnUpqykfYxOoepQokLBLP4K3dsRW3b6WLCikP/ppVATt6Iyeav0+ZXSP1PInalk6EWnkFbyOHvZPkZIqPj5M8fxss/ehc/fvhcAlhWE3Eyn8/jOw4cbVFl5eOQgJHromsCG/g4MURQihESUiCzfSL1xRKFq2sfsXQ26IKrCmT4mJebtLIvepOGZ/JbNu0OnLbEoSF3BLYRU6vyJ2kh69RDLjaRXwdLaIqcQg6YJCSO/2nMSt+0ads4/fmgcAPD1+w6s6HarHRy/3yfAur5Ed5R9JeHblbTbLUdE/gwtgm1s0SXVn2T7GCEksrB9rE2ppX2sINk+Vgve9jErU6inI4aJuayzT7bgbiXzFx2aifA4hSoUhXycNWFmUaaQ6X2suk/7mOHKFFosChWdQlHJVQoSIcRmAN8DsB7WKvdaKeW/BlsViTJ/+r3tzuknP3HZsvs36lN62Ze9E76iK+HUHzMkT8Zyh+h6CFO1IPluiSyp/k48VMOkQkIICQN0CrUpTtB0FSNzC6Zqm+GCtxqK7WPS1T5mIGf6j6RXQl1pe1Iz8WYKVXqdxdcNM8LHKeQuXTniPNuWyBRyO4WCfO0iRB7A30gpzwPwCgAfEkKcF3BNpEX4u5ufrZtbZLmbufu5k0teXonAsOxI+hZ0kETpEQUlEpHokBpI4uRM2uP8JoSQqMClS5uiFra5Kn62U/oRXRDVofmIQj0dMRQK/kHT5ZwozUSrwSlUnD7WiIrqj3pc6su+lN6FmeMUcj0ZMVemUGl2EtvHqkNKOSyl3GGfngHwHIBUsFWRqPHzZ47jkz/bjRseP+rZfqurjawc9TrEfuC725ffqYn8aPsxzKRzQZcRKXjEJitlU38SUgInptJBl0IIIVXD9rE2RbWPVecUCt7BEkXU8yUlMJ/NQxNAV0L3Bk3nwxY07c4UqvA6EWsfU1WaZtEpZIjim9uwVR+3wGNownl9SrOWuuIGhLBeZwqn1SGE2ArgYgCPBVsJiRp/+cOnar7u7qHKgqd/0/CMoPrx9LFJfOzHO3H/b07hq1deXPH1ZItZYXgEJs1GjaUfnJzHltWdAVdDCCHVweV9GyKlRDpX/fQx1WZjUBWqCscpJC2nUGfcgKFpHlHI3ynU3DrdCE/7WKsGTZdkCpUETRfbx7xOIdV6Wfo4NU2gO244p0llCCG6AfwEwEellNMll10lhNguhNg+OjoaTIEksiz3Kaw0FPaHJS6kRqA0mZUePuft3LrRmercCvfu4+eLkJWQ6rdEIU4gI4REEa7u25Csz/jzSlBOoaiMHA8LymliSomFbAHJuA5dE97pYwV3plAYnELu0xW2j/kEM4eZxZlCZdrHXNtiunA5uRbfpmohi8pzEDRCiBgsQeh6KeVPSy+XUl4rpdwmpdy2du3a5hdISJOpdNpjKelcAe/++sN4bnimpuvP2WISIaQ2NvR3AKhcbCaEkDDB5X0bknG1KlXjFHLax7jgrQrHkWJnCnXFdRia8DqF8mEThaoPmlZXiYqRTAhht3tZr4Ms4xTytI/pGjI5ezqczxOjJpDRKbQ8wlr9fgvAc1LKLwddD2k9ahVYosiOoxN44vAEPvOLPUGXQlbA7btPBF0CqZGEoWNdT4JOIUJIJInI8o3UE9X+AgB5sxanUPt80a4H6ukqmMB8toBk3IChe9vHcj7tY0GuZ9wvcaULKz1i7WOAVat6FSS8j1tlCokSoWipzCfHKcTPSCW8CsAfAHiDEOJp+9/bgi6KkHpTjzHjETqshoKoCoIHIpRfRRaTGkjSKUQIiSQMmm5DVMg0UBx/XgkFSVGoFjztY7k8Om2nUKGMU8gZeR7g8yxqcAr5TesKO5rwjqT3dQqVZAqpz4zfw+xm+1jFSCkfBPNgCfHQaoHPhLQTqf4kdg1NBV0GIYRUDZ1CbYi3faxyp5BJp1BNqDYl0wma1mHoliikFgBucS4MQdPe9rHKChERdAoJIYpB06ZXDPMTuQxXwJCf8FNsH2tEtYSQVkUdTqgJBUNUnUUkXKQGkhieTDvflwkhJCpw6dKGeNvHKv/DpfalC6J6NGGJQAvZApIx3XGhqOc0mzeRMKyPYzgyhVynKzxKRLN9rNQpVLwspqvpY+5txSfDbxHBoGlCGs9D+0/hySMTQZcRGFEQjr5x3wFsPzwedBkVU3rEZrYPqYVN/UlkCyZGZzNBl0IIIVVBUagN8baPVeEUsr+JMkS3enTbkaKcQrqttKgWsmzBRDKuO6eBoDOFahlJ7/0/CmhCOAssKb2PVb1GbqdQTHc/L4tvj5lChDSe9133GH7naw8vu19YtNl6iDhREILcfO72vfjdrz+y9E4NfH1C8tKTNmPTQCcAYJBh04SQiEFRqA1Z6fQxgwveqtE01T6WR2fCcMQFJcpl8yY6Y5YolMsHP+XNfdcVi0IRzBQSKLZFmlJ6XFHqfe7NGSru4Pc433L+afiz157JVgRCiEMlf2WjJvq0GruPl8+Bedln72paHXwbRJvUQBIAx9ITQqIHg6bbELcolKth+liU2oPCgmofm0nn0Z0wHEFBPac5H6dQkC1IbsGjcqeQareKzvtDc2cKSembKeQRhVxOIb/HefGWAVy8ZaBB1RJCWp1aD5+ihbwx1U5rqySce2QmjXU9HUjnCrhn78giEe4PvvV42euOzmTwmi/cU1VNpD1J9duiEJ1ChJCIQVGoDUnniu1jtTiFouQECQu6EJhN55HJm1jdFXdcKCpgOps30Rk3nNNA0JlCtUwf8/4fBVQAOLC4fUy5udyPJ+ZyCvFjQAhpFhHS2pvOjdsHl93n0s/ejYeufgM+cdMu3LNvtAlVkXakK2GgvzOGwYn5oEshhJCqiNDyjdSLjGu6Vb4apxBH0teMENYvlQCwujsBQ/dmCvk5hUSAn073AqRS548SVKIUsuzOxzKl9PzWrjKFyjmF6JgjhKwEP4NLtW1kpinx0P5TZd019z0/iq1X34pTLRx8+7/u2Ltom9/h+VWf/zUFIdJwUv1Jto8RQiIHRaE2JGM7hbriBrL5yr+BmmwfqxldExiZsb6Ur+6OO8KaEuWyBYlOJQpF1CkU3fYxlSnkfaxOppAnaHrpTCFCSHiISkuVEKJmJ9B/PnYE77vuMdxRMi1LiUvffvAQAGDXUPnMnFZkfC4bdAmkTUn1J9k+RgiJHDWLQkKIFwghnnb9mxZCfFQI8fdCiCHX9rfVs2CycpRTqCthVOcUYtB0zbhFobXdCac1Ke+0jxUcUag4kj6AQm08olCFhegRDJpePJJ+sStI92kpA9jOQQgJnsOnrDaV45PpgCupH/UQ83YcnaxDJYRUT2rAcgpVknVFCCFhoWZRSEq5T0p5kZTyIgAvBTAP4Cb74n9Wl0kpb6tHoaR+FEUhvapMobxyCkVo0R8WhBAYm3U7hayPXt5pH5OI6xp0TYTEKeR/upLrROntIVxB01KiTNB0cX9Dd2cKReiBEtKGhOYjGrLF4dRCLugSLMo8LftOzuBztz3X3FpCQsjeKqQGUv1JzGcLmJwPyeeMEEIqoF7tY28EcEBKeaROt0caSCZvtY91d8QcV0olmMwUqhndJT6scgVNO+1jeRNxwxKFlFAU5ILGLY5UnCnk024VdjRRnFxjOYWKl6nx8572MW2xaEQIIc1kpX8bfvDY0foU0kC+cf/BoEsgpCY2cSw9ISSC1EsUei+AH7rOf1gIsVMI8W0hBOczh4xMznYKxXVHgKgEpR9FKUg4LCgBoafDQMLQi6JQoRg0HdM1T2teeJxC1QVNR8lBIyCgOihLp4857XCeljJOHyOE1BcpZVUOEb99I3TYJQQAIIR4ixBinxBivxDi6iX2+x0hhBRCbGtmfbWS6u8EAAwyV4gQEiFWLAoJIeIALgfwI3vT1wCcBeAiAMMAvlTmelcJIbYLIbaPjnIaRDPJ2K6UuKEhT6dQU1Bf2Nd0JwAU82pUTpNyCoVHFKphJH0Up4+VZgq5x8/ri51PhidTKDqPk5B2JCyf0HJ6j98hpNxhJSyPpZ789+seC7oEEhBCCB3ANQDeCuA8AFcKIc7z2a8HwEcARObNkqJTiBASQerhFHorgB1SypMAIKU8KaUsSClNAN8EcKnflaSU10opt0kpt61du7YOZZBKyeQLSBgaDE1DropMISVgUBSqHvWcremOAyi2JhWnj5mI61ponChucaRip1AE28fcmUJm2Uwhd/uYa/oYRSFCSAAwdoa0AJcC2C+lPCilzAK4AcAVPvt9BsD/AhCZJPWBzhiSMZ0TyAghkaIeotCVcLWOCSE2uC77bwB21+E+SB3J5E0kDB0xXVQ1fcwJmuZauGqUgLC6y3YKudrHpJSWKORyCgkRrBPFmylU2XWiGDStacVMIVkuU8i1zT19LEptcoS0I2H5iK60NayUu/acrL0YVP+8qOEHhNSRFIBjrvOD9jYHIcQlADZLKW9tZmErRQhhTyCbD7oUQgipmBWJQkKILgBvAvBT1+YvCCF2CSF2AvgtAH+1kvsg9Seds51Curbk9LHdQ1P4yA1POWHUpmktmtk2Uz3qKVttO4WUC6VgShRMK0/CnSkUtODgbR9r5ZH0wvnVvexIek/7WPGQyY8BIaReVHM8qSSEWUrgmWP1Gcv+r3c/X5fbIcsj6QMDAAghNABfBvA3FewbujiKVH+S7WOEkEixIlFISjknpVwtpZxybfsDKeWLpZQXSikvl1IOr7xMUk8yeROJmIaYJpBbwin06MEx3Pz0cTw3PA0AKEjpuCdIdShhYbWTKWQ9jznTcgkBsJxC+mJ3ShDUEjStxMIoiYaaEK5MIe9j9RPoPE6hoF8kQggpw+OHx3HFNQ/hsUNjK76tkelMHSoixMMQgM2u85vsbYoeABcAuFcIcRjAKwDc4hc2HcY4itRAku1jhJBIwRV+G5LJWe1jhi6WdAqpvKHdQ5YoZJreIF5SOUpYKGYKKaeQiVzeep7dTqGghZV2CZoWAq5MIen5td4vU8hgphAhkSHo4+hyVNNWthzlHmk619jWr/946BCmFnINvY92QrRkpLgvTwA4Rwhxhj2w5r0AblEXSimnpJRrpJRbpZRbATwK4HIp5fZgyq2OVH8SE/M5zGfzQZdCCCEVwSV+G+IETetLB02rtrFdQ5YRLG9KLoRrpCgKWU4hJTjkChKZQgGAcgopISKAIl24X+ZKF1aRzBRyOYVKR9IrAcjVMeaZPhalx0kICQ9X/NuDnvOPHxpfcv+dg5PLHoer0ZeqPXT9YqfX8P3jJwed0//w8z34+E27qrxF0u5IKfMAPgzgTgDPAbhRSvmsEOLTQojLg61u5WxSE8joFiKERAQj6AJI87GCpu32sSVG0qvLdtuiUMGUbJmpEad9rMtyCsVspaFgSkeYi+sCuhNuHD2nUBSnj2miGDRtSulZLBk+I+ljnkyh6DxOQlqR//PE0SUvD+sn9JnBqUXnL94yUHb/y//tobKX1XoYGp3JLJtf8/NnjsPQBBZyBWfb6754D46MeQN0p+bpFCLVI6W8DcBtJdv+rsy+r29GTfVCiUKDkws4Z31PwNUQQsjyUBRqQzJ5E33JmB00XV4UUlk3+07MIJs3YUoZqRDhMKGettUlTqG8KZ3JLu7pY+EShSoMmo5i+xgEVKyWKb2ip99rYbgu52eBkGD5nz+JhkOlmvDghh0+XSV87va9+Nztez0X//q5Ec/5rVf7D3wqFYQIIYtJ9XcCoFOIEBId2D7WhmRyBXTYrUo5c4n2MTvrJlsw8fzJGRRM6VkUk8pRYoPKFFKBxfmC6TiyYnqxfSxoXaWWoGkVtxOl3CkrU6gYNO2XKeQWuWJG8cHxo0AIqTe15gwtd70//s4TS17+06eGlrx8yfvmxCxCPKzrSSCmC04gI4REhggt30i9yOZNJGI6YtrSTqG8azLZ7qEpq30saLUiouhCwNAEejti1nkfp5A7aDpoF4q7NarSl1y9N6L0HrEyhazTsmQkvWoV87SPaWwfI4TUn5UeTtSU0DDy2MExTjAjbYWmCWzoS2KQTiFCSESgKNSCPLT/FF75ubvLTj1QmUKGbi2IzTJuoVzBxNqeBHo6DOyyRaGgxYqoogmB1d1xR2BQIcb5QslI+tBkCrlOV/iaR1IU0gDVV2GNpC9eVpw+VtzGoGlCSLXUc8pYOcLsSPi9ax/Fa794T9BlENJUUv1JDE2w3ZIQEg0oCrUg+0dmcXwqjfG5rO/lavqYckLkTH+3UDYvEdc1XLCxz3IKSTqFakXTgNVdCee8EheskfS2KKSHZ/pYTSPpQ+JyqoalnEJ+rq2YSxSK0uMkpC3hR5QQEhCpgWSoxVpCCHHDoOkWRLUjqf9LSedMJAzdlWsjkfB5J+QKJuKGhnPXd+Omp4Zwxpouj1OCVM57tm32THoz3O1jhcVB00G3JtUSNK12i5JWIlwj6a1MoWLxa7oT+INXnI5Xn73G2WZo7kyhCD1QQtqQiTI/jDSTv7j+Sdy268Sy+81nrAlfe0/ONLqkutMMJxQhUSPVn8TITAbZvPVdmhBCwgxFoRZEiQyZMqJQJl9AIqZ5Wpj8yBVMxHSBDf1JTKfzmFrIRWqyVJh41yWbPOcNvfjcu4OmiyPpm1tfKe6XudrpY1ESSzRhiUFqLH1p29xn3nmBZ3+3KBqhh0lIW3Lj9sGgSygrCB0tmeL16KExAMCtO4cbXhMJLwztbh1SA0lICQxPLeD01V1Bl0MIIUtC6boFUWKQnyhUMCVyBWm3j1mr2nLtY7mCCUPTsLE/CQAYnFioOF+GLI3hEzQd14uvSdDCirs1qtXbx6SUTgvZcs97XC8eMimQEkJqpTRjh6PeCWktNtnfnTmWnhASBSgKtQBSSvzlD5/CA78ZBbB0+5jaljB0j1vFj2xBImZoSPV3AACOTcxzIVwnnOljBRNZ+/mPG8IVbhy99jElGEZJOBSwRtKbPk4hPwyd7WMkOhw+NYebn6591DhpLDetYAy8olybeDNh+xghi0kN2D+oMleIEBIB2D7WAuQKEj9/5jg2DyTxmnPWOl8SM/nCon3VtoQrvyZXZix9Lm8irltjNQEriyhKC/4w4+8U0p3w76D1Bk8bVYXFvDjVh//3jefg5WesalBV9UcTAqYJRxRaLsvJ0Ng+RqLDm//lfmTyJq64KBV0KTUxnc7hkk//KugyFpHJF/Dpn+9Z8e3sPbHy/KDvP3pkxbdBCKk/G/qSEIJOIUJINKBTqAVI20KP4xAqeM+7US1liZhr+lg5UahgIqZrWNeTcBwsBkWhuiCE5Qqy2vnsTKEQOYXc4oio8CgR0zX89ZvORWc8OlqzEJYgJCtsH1OfGU0EHwZOyHKUy5Wrltt3DeP+50frclvV8PyJGeTN8NlQbnn6OK5/7GjQZRBCQkzcsL4/cwIZISQKUBRqATI5JQZZ/+fy1pdovwWB2rfD0J3Q3HJfupUoZOga1vdY49TpFKofhiaQM01PppDhiEJBVlabUyiKWJlCqKJ9LByiHSHN5M+v34H3f/vxmq47PLXgKyiNzKRXWlZgsF2KEFIJqf4knUKEkEhAUagFSOcsZ1CpOLRk+5hr+lg5p1C2IB1nhAqb5kT6+mFoAgX39DFDK4oOAatC3kyhAAtpMJpmTXtRuuhyWk/MmQ7Xwk8KIUvw5V/uw093VD7V6x1feRDv//bj+OKde3HHbmsS10P7T+HSz96NO59delT7V3+9f0W1kubAiVmE+JMa6KRTiBASCSgKtQBK6FFi0FJB0xlX0LSadLXUSPq4Ye3jiEKtrBA0GV0TyJvSeU0sp1A4RIdagqajiCYETI9TaJlMIfsz08JPCSFL8pVf78df3/hMxfuPzWUBANfccwAf/M8nAQA7B6cAADuOTix53fsCaFmrBIoghJBKSPUnMTy1ADOEbbCEEOKGolALkM55nUFLjaSfz1r7dMS04vSxJUbSK6fQBnsCGUWh+hHTNeRN03EKhal9zC16tLIAIoSwMoXM4vmlUJ8Hfg4IqZ3vP3IYANuwCCGtTWogiVxBYmQmE3QphBCyJBSFWgDVPlYMmi7vFJrL5AEA3QkDMWf6WBmnUL4oCqXoFKo7Kmg6mzdhaAKaJqCHJLPG3b4WdC2NRBMocQotvX8sJK8PIVHm+JSVJ5QrmPjHX+zBRZ/+ZcPv84nD4w2/D0JWDIXSlmKT/d15aHI+4EoIIWRpKAq1AEWnkBKDvI4hNzMuUchxCpUThUxXppA9lp6L4fphaAK5giUKqedZZdYEPdmqvYKmZcXtY2pqXAs/JYQ0lesePITJ+VzD7+cfb32u4feRzhXwoet3NPx+CCHRIDVgfXceZNg0ISTkUBRqAZygaVsEUs4fP1FIOYW6Eobjesgt0T4Wt/dh+1j9MXQNBVNiLptHV8Ia466HpH2sXYKmBeyR9Pb5Sh6roQl+DlK7jgQAACAASURBVAipA1FtHytX94O/OYVbdw03txhCSGhJOU4hikKEkHBDUagFSOdL2sfy5aePeUWhZZxCPu1jBhfDdcOwg6an03n0dliiUFjak7yZQq37mgshYJrF9rFKHmtM1wJ/fQgh1fHs0FTdbutf7vqN7/bx+Wzd7oO0JxHVSUkZuhIGBjpjHEtPCAk9RtAFkJWTWdQ+Znq2u5lVolBcdyYp5cuMpM8VJGKGJQr1JWNIxnQuhuuIoQvkCybmsgX0dCinkJo+FmRlRVEq6DoajZUpJJ1f/it5fxu6aPnnhZBqufu5k9jQl8R5G3uDLsWXfB2n/5yYTi/atvXqW50fT9qNqDq+CGkGqYEk28cIIaGHTqEWoOgUKhlN7yP2zGXySMZ0GK7x5zmfL8tSSmRd08eEEDh7XTf6O2MNeQztiK5pyJsSs+kcejqs51U5sYJ25xRFodZWP9TjqzRoGqBTiLQev/u1h3Gb3fb0qz0ncevO6lugPvDd7XjbVx6od2mRgi0ihJBSUv1JHhsIIaFnxU4hIcRhADMACgDyUsptQohVAP4PgK0ADgN4j5RyYqX3RfxZHDS9lFOo4OTXOJlCPtlD6ldVlSkEAN/6o21IGHodK29vDM1yCs2k81jfa2U2KfdW0Jk16u5bXfzQNEsQMqtwCsU0gTqaDggJnO1HJrD9yAQOf/7t+NPvbQcAvP3Cty95nYIpsZAroDtBwzHxsuMov+4Rokj1d+L+509BShn4D36EEFKOejmFfktKeZGUcpt9/moAd0spzwFwt32eNIjSkfSZfHmn0Gwmj+6EJew408d8gqZz9nXVPgCwrqcDfUk6heqFoVuZQjPpvLOwMkISNK2+uLT69xchLIHHNFWm0PLXMXQt8NenFRBCfFsIMSKE2B10LaR6/ubGp3HBp+7EHbtPNO0+P/wDTvaKAv//T3YFXQIhoSE1kMRCroCJJkxZJISQWmlU+9gVAL5rn/4ugHc26H4IgEzO2zamBB213c1cpjjpKmavbHM+QdO5vLUtprPDsFEYmkDBlJhxt4/p4RpJ3/JOISFqyhQK+vVpEb4D4C1BF0Fq42dPHwcA/O1NzRMAfrFz2HeAAgmWpYyT//HQoabVQUgYcSaQMVeIEBJi6rHilwB+KYR4Ughxlb1tvZRShRKcALC+9EpCiKuEENuFENtHR0frUEb7ki5pFyt1DLmZdYlCjlPIx1GkBCZ3+xipL4amIZMvDZoOh1OonYKmpXRlClVwRIxpWuDtfa2AlPJ+AONB19HuSFdK8DPHJgOspDJGpjNBl0B8yBdMXHPPfvxi53FIl0z0Dz/fE2BV0YN/WVqPTQNqLP18wJUQQkh56hEG8Gop5ZAQYh2AXwkh9rovlFJKIcSiH5KklNcCuBYAtm3bxoSOFZDO+QdMZ31EobnM4vwav6ksym1Ep1DjMHSBkRlrhHFPyEbSt0vQtIDKFLLbxyr4Sm7oAlq+wYUREgBXXPNQ1dcZm6t9DPv+kdmar0vCw+OHxnH2394edBmEhBLlFOIEMkJImFnxil9KOWT/PwLgJgCXAjgphNgAAPb/Iyu9H1IeJQoVTIlMvoCCLfL42eznMsX8mpiaPubXPkZRqOHomsDUgtVj3mu3jxVH0gcrxqi7b3FNyGkfU7po5ZlCLf7EhAQ6SlubB/efCroEQghpKP2dMXTGdU4gI4SEmhWt+IUQXUKIHnUawG8D2A3gFgB/aO/2hwBuXsn9kKVxt4nNposWBv+g6YKrfcx2Cvns54hCBkWhRmFomhM82N3hzXkKWnNwnEIt3iYlhIBpFltoKhF74rpo+eclLEgpr5VSbpNSblu7dm3Q5USGqfkcjo2Hs1XhymsfLXvZHbuHnYWTWWbE36FTcw2pixBCGoEQwhpLT6cQISTErLR9bD2Am+zQVQPAD6SUdwghngBwoxDiAwCOAHjPCu+HLEHaFSg9mymKQv4j6XPF6WMqaNrny3c2v3gkPakvKmgagE+mUNDtY+r/1n79rUyh6kbSGxqnj5Fwc9k/34fRmfLZO3c+ewKfv30vfvahV6GnzEh505QNET8fOThW9rIP/ucOrOlOYPsnLsO7vvaw7z7v//bjda+JEEIaSWogSacQISTUrEgUklIeBPASn+1jAN64ktsmlZN2iT8zSziF8gUT6ZzpOIWEEIjpwtcppMbUs32sceguwU1NH1PPd9CiQ/sETQtIuIKmK2ofEy0vljUDIcQPAbwewBohxCCAT0kpvxVsVa2BnyAkpcTeEzN40YZe/Nn3nwQAvOQffok/fc0Zvrfx853HccVFKc+2x5YQdOrFqVmr9qcjEHpNCCGVkOpP8phGCAk19QiaJgHj5xQSYrFTaC5r7dft+mXY0DQGTQdETHOLQuFyCol2cQpp8Iykr2TUfJyZQnVBSnll0DWEhXSugN/9+sP41H89Hy/buqrut7+QLeA/Hj6EL9yxD68+e43nsm8+4D8y3P13RfHv9x6oe22EkCKcutKapAaSmJzPYc41AZgQQsIEV/wtQNonU6g7YSwKmp6zBSP3HyRDF44A5Ea1j1EUahy6a/65EoVUS1/QmTVCCGii9UUhIQRMWZ1T6E9ecyY+etk5Da6MtBP7R2axe2gan7r52bL7SCnx0P5TnhHylfJ71z6CL9yxD0Dl4c7bD08s2nbf8wz7JoSQalETyNhCRggJK1zxtwCZXMFxdsxkitOsSkfSK1HI7RSK6RryS0wfixutLQoESczdPpaw2seMkLSPWTWIUNTRSFSmkKwiU+i/nLUav33+aQ2ujBAvP90xhPdd9xh+9ORg1dfdOThV9XVquR9CCCGL2TRgi0IMmyaEhBSKQi1AOldwwkK9TiGvKDTrIwoZmr9TiO1jjUe1ihmaQEdM82wLg0NHE6Kidqooo5U6hfh2JyFl0F5MDIZ0qhghhBB/Uv2dAIBBOoUIISGFS6AWIJ0z0Zu0nCbTShTqMJA3pTPdCiiKQl0lTqHcEk4hikKNQ7WK9XQYjvii3ENhEIWEaH2RRMAShJQo1OoiGCHN4JLP/Ar/fu/+qq7jN/CAEEJagXU9CcR0QacQISS0tPiSrz1I5wvotadXKeFHZdS4W8iKmUK6s83QhTNpzE22wEyhRqNaxdTkMaDoFAqDNmG1j4WgkAYihIBpVjeSnpAgiUIQ7fhcFl+4Y9+iFualOP9TdzawIkIICQ5NE9jYz7H0hJDwwhV/C5DJmeiznULu9jHAKwrNZvymjwn/TCH7enGKQg3D7RRSFEfSBy9OtEPQtCYEpIQT3tvqGUokuqiPYg0504Fx7idur3jf0nZnQghpJVL9SQxOsP2XEBJOuOKPOFJKyymUtDOFHKeQJRK5J5D5TR+z2sfKZwoZOlfJjUI9t25RqJgpFEhJHqxMoaCraCyasJwXdAqRIJiYy2Lr1bfi1l3DZfcxTYl/uu05HA/xL8y1TERbil8+e6Kut0cIIUGT6k+yfYwQElqM5XchYSZbMCElHKfQTNrbPpbxOIV8gqZ1gbzJTKEgUCPpuxPF9rGYFh6nkGgHp5AmvJlCAddD2ov9o7MAgO88dLjsPruPT+Ha+w8652UkGshWxlXffzLoEgghpK6kBpIYmckgky8gYejLX4EQQpoIV/xVct0DB3HdAweX37GC2/neI4ervt7eE9P4s+9vRzpnOYDSOUu8UZlCM2lrJL2aRpYpyRQyNIGEUXzZDc3fKaQyhdg+1jhU+1iv2ymkq0yh4OUJTWv9kfRCMGiaBEclBpvl9playGF0JlOfgmokSi1thBASBKl+ayz98GQ64EoIIWQxXPFXgZQS37j/IG56amjFt3Xj9mP4+TPHq77eXXtO4s5nT2LfiRkAQMYWh9T0MccN5DiFiu1js5k8uhKGZ+Eb072ZQjc/PYThqYWiU8jgIrlR+LWPKaEoDFpcOwRNq5H00mkfC7Ye0no8cXgcdz930vcy6YiR5a9feplbgDk1m8HL/+kuvOyzd620TF9GpqtfvGy9+tYGVEJIe1DvVkwSHlIDlijEsGlCSBgJwdIzOhwbX8DoTAbjc9kV39boTMYJfq6GI2NWSN3BU1bbgXIK9ZWKQr5B03lP6xhgOYXU9LFj4/P4yA1P48YnBp2gabaPNY5i0HRs0bYwiDGaaH3njCasL+HKKaRRFSJ15t1ffwQf+O52bL36VkzN5zyXjdl/S9zvuo/96Bk8tP+Uc750gleuYCKdK+DjN+3Ctn+8y/kb0Aje+KX7UPBpLy6Fy1hC6gM/S63Lpv5OAGCuECEklHDFXwXbj4wDsL7Ir+TXnFzBxMR8zgl+rgYlCh0YmQNgjaMHUAyaTpcGTXvbx9zj6AEgZmjI2U6h+54fBWC1oOXshYDBRXLDUJlCXqeQtS0MYowQrd8+ppxCJp1CpI7sODqByfksJkp+QDhgi/mKv7h+BwDv5/1HTw7ifdc95pz/3a8/4rnONx84hD/57nb84LGj9S57ETOZPM76+G0Nvx9CCGl1TuvrgBDAIJ1ChJAQwqDpKth+ZAKA9cvtXLawyHVTKWOz1kKhJlFo3BKDik4hNWbezhTKlA+anssUPJPHACCmCccpdL8jCuURMzTEdS0U4kSrErPbx7o7vMHfQDjEiXYYSS9gZQpJZgqROvKuf38Y523oxZ7h6Yr2r/Zd96DLSRQG2PJCCCFLEzc0rO/poFOIEBJKIu0UunXnMD5yw1NNu78nD084p8dna28hU6GgM1WKQgvZAk5OW9dVTiEl+nTENMQNzWk1qLh9TBfI5SVyBRMPHxhz9svlTUe0II1B92kf00PVPtb6TiEhBKQnU6jFHzBpGn6CUNl3l88Fx8bnsX9kdvEFhBBCIklqIImhyfmgyyCEkEVEWhQ6dGoWNz993BOm3Cim5nPYd3IGF2/pBwCMzdU+7eXUrHXdbN70nfxVjqPj1h+SjX0dODQ2h4IpHadQR0x3pooZmkAybrWJuZ+bOV9RSEPONPHU0Uknj2gmk0euYCJmRPrtEXpiPu1jKsMpDGKMJkTLO2eUCKRyU8LwvJNokskX8BfXP4mjY+W/8Ls/TyMzxRBntfXw2Jyz7TVfuAeXffm+utdJCCEkGFL9SQZNE0JCSaRX/QNdcQDAZEl4ZyPYcdRyCb35/NMAYEVh0+7xwdW0kKkFw2+9cB2yeRNDEwtOyGiHURSFYrrmnC51Cvm1j2XzJu5+7iR0TeAlm/owm84hW5AMmW4wus9IeiVKhEGMEaL1RRL1+PKOKNTiD5g0jIf2n8Jtu07gU7fsrmj/Sz97t3Nafd7ns43/gaMRsHmMEFItQoi3CCH2CSH2CyGu9rn8r4UQe4QQO4UQdwshTg+iznqSGkhieDJdUYA/IYQ0k0iv+gc6LVGoHtPAluPB/adgaAJveOE6AMWpMbUwOlsUhWaXEIU+esNT+OTPigsM9Qu0quHA6KzLKWRlAAFW33LcFoUyy7SPJeM6BicW8I37D+Lizf3Y0Je02scKpnN7pDF02m4u9T4GrMVhTA/HKPi2GEmveZ1CLf5wSRNY6qt+ubdXPd93zfh7SAghK0EIoQO4BsBbAZwH4EohxHkluz0FYJuU8kIAPwbwheZWWX9S/UnkTelxihJCSBiIdNC0WkyXTnipN9PpHG584hjefP5pSPUnAdTTKVT+l+FdQ1PoduXNHB6bQ39nDJdsGQBgiUJqFH1HTEciZokMcUNDwrBOK6eQlNJ3+tifv+5snL2uB1JKvPbctfjm/Qcxm7bbx5gp1FDe8KJ1uO7923Dm2m7Pdl0LR5ZPWwRNO04h63PS6o+X1Id79o5gOp3DFRelnG3Clnzu3Tda9nrl3l71eNc9enAMrzhzNa689tE63Fp1MGeaEFIllwLYL6U8CABCiBsAXAFgj9pBSnmPa/9HAfx+UytsAKkBaw0xNLGADX3JgKshhJAikRaFVtntYxMNbh/74WNHMZPJ44OvOwudcatNa0WiUIVOoamFHLKuzKGj4/M4fVUnBrriGOiM4cDoHM7b2AsASLidQrrbKWSJTgdPzcGUwOaBTs99bFndiQ+8+gznfHeHgRlHFKJTqJEkDB2Xnbd+0fYPvf5svPLs1QFU5MXKFAq6isayOFOoxR9wG/Lc8DQm5rJ45dlr6nabf/ydJwDAIwo9e3yq5turR7voe699FI99/I3Yd3JmxbdVLed+4vam3ychJNKkABxznR8E8PIl9v8AgMgfaDbZPywPTS5gW8C1EEKIm0iv+ge6LJfM+PzyAk06V8BCDXkNmXwB33rwEF519mq8eFMfhBBY3RVfsVNICTjlRCEpJaYWcp4pZ4fH5nD66i4AwFlru3FwdBYZd9B0zLrNhFHMFMrYmUNqctq2rQNL1taTMDCbzSOToygUFH/5xnPw0tNXBV2GnSnU2iLJ4kyhAIshDeG6Bw7hYz/eueLb+cdf7MHWq28te/kvdg4vexuaEDh0am7R7dSr5evl/3T38jsRQkiEEEL8PoBtAL5Y5vKrhBDbhRDbR0fLOzXDgHIKDXIsPSEkZER61d+frLx97H/+ZCc+9IMdVd/HvftGMTKTwVWvPcvZNrBCUejUTAZbVluOnXJB0/PZAnIFiblsAelcwQmWPt2+3llru7F/xJUpZOieTCFDs1weymm0/cg4+jtjOHNNt+/9Kbo7DEhpuZTYPtbeaEJAi/QRYnlUyw8zhVoXXQPMOvQ3XffgId/tOwcn8cTh8YrdPjc9NbTiWgghrUkb/QkaArDZdX6Tvc2DEOIyAH8L4HIppe/YXynltVLKbVLKbWvXrm1IsfWiM25goDPGCWSEkNAR6SVf3NDQkzB8BZrDp+bw7q8/jCm7tew3J2dx+NTcov2WQ13nEnsUPWC1ra00aHqrLe6UcwpNLhRb4sbnshiaXIApgS2rrOudt7EXY3NZHB6bhyaAmC6clrG4oUEIgYShOUHT249M4KVbBpxg3XJ0J4ruKzqF2pt2CJoWJU6hMEx9I/VFE8J30st7r31kSecPAOw5Po2H959acp/L/+0hvPvrj6yoRkIIaTOeAHCOEOIMIUQcwHsB3OLeQQhxMYBvwBKERgKosSFsGujEEJ1ChJCQUfOqXwixWQhxjz0u8lkhxEfs7X8vhBgSQjxt/3tb/cpdzEBXHJM+7WOPHRrDE4cnsGd4GoAlxExU0GZWyvBUGj0JAz2uwGerfcz3B4tlSecKmEnnsdVuAyvnFHI/pvG5LI7bvypssjOBLkhZWUJPHplAwtAdEQiAI+YkDB3ZvImx2QwOjs5h29blW5J67PHoE3MUhdodIVpfJHEyhQoMmm5VNE04TqGP3vAULvr0LwEAjx4cX/a6b/vKA/jv1z1Wt1re8dUHnZw3QggppV0y26WUeQAfBnAngOcA3CilfFYI8WkhxOX2bl8E0A3gR/Z64pYyNxcpUv1JDE7MB10GIYR4WEnQdB7A30gpdwghegA8KYT4lX3ZP0sp//fKy1uega44xn2CpkemLdFmZCaNgikxZoc7m6Zc1i3jZmhyARv7vRMCVnUlPFk/5TgyNoc13Ql0ucbAq8ljW9csLQpNuR7T2FwWp+zrndbXAQA4b0MfNAEcOjWHgU5LsHKcQq42sky+gCePVJYnBFjtY4DlVIoZFIXaGV0TaPUOQnUoKEjvedI66EJAGYV+9vRx330ePzSOkZk03nHhRjx5ZALjc1m8yScEfilkhS1q37jvYFW3SwghrYiU8jYAt5Vs+zvX6cuaXlQTSA0kce/zI5BStvwPb4SQ6FDzql9KOSyl3GGfnoGl9KeWvlb9GeiM+WYKnZxJA7DEofG5LEwJmNIaL18NxycXsKG/w7NtdXfcyfoph5QSl//bQ/j6fQc829XksY39HYgbGmbLjKSf8rSPZXBi2no8p/VatSTjOs5eZ+UDddij6NUYeiUOJQwNmZyJJ49MIK5reHGqb9nH22MLWFIC8VZXBMiSrOlOYE13IugyGooSiAscSd+yaAK+7WNu3vONR/DhHzwFAPidrz2MP/3e9qrvZ++J5k/9IoQQEi1S/Umkc2bdBgwQQkg9qIsVRAixFcDFAJTP/sNCiJ1CiG8LIZa3p6yAVZ3+oc9up9Ap1wj4ySrH1w9PpX2cQlbA9VIH9In5HKYWcjhUkmOkHD9ruzvQnTAwm/Gvx50pNDabxYmpNPqSMSTjurP9AlvkUaKQO1NI/Z8pmNh+ZAIXpHqd/ZZCOYUAsH2szbnmfZfg01dcEHQZDUU4I+nV+QCLIQ3B3T5GCCGEBImaQMawaUJImFjxql8I0Q3gJwA+KqWcBvA1AGcBuAjAMIAvlbleXUZIlssUGrHFl5PTGadlC0BFuULX3LMfjx0cw0K2gPG5LFI1iEInptL2/ac925VTaG1PAl0JHXNlnEJKvBLCup8T02ls6PM6lpTzJ+EjBlnbdUwv5LBrcAovqyBPCIAnO4miUHvTnTA8ImQr4rSP0SnUsmhCwFzGKUQIIYQ0A7WmYNg0ISRMrGjVL4SIwRKErpdS/hQApJQnpZQFKaUJ4JsALvW7br1GSK7q8m/lGrHFmJGZtEcUWs4plCuY+NIv9+E7Dx/G8JR1wC4VY1bbolDpBLKRmTSeOGyFlyox6ESpKGTXsro7jq64scT0sSzihoY13QmMz2VxcjqN9b3+olCxfcwWg/Ri+9jTRyeRLZh46emVGba6E3QKkfZBiUBq+hhFodZD14qZQrWyf2TWd/tUlc5TQggh7c0mOoUIISFkJdPHBIBvAXhOSvll1/YNrt3+G4DdtZe3PAOdlkDjFnuklI4jZ2Qm45wGlncKnZhKw5TArqEpHJ+0BJ3y7WPeCWT/48c78f5vPQ7TlBhWTqGpjCeAdGQmg1VdccR0Dd0JY8mg6f5kDKu74hiby2J4Ku3kCSletKEXQgAdMa9DKOYKmp6xb78WUShucIFMWpuiU0h6zpPWQRMChRW2j33xzr2+2//mR8+s6HYJIYS0F33JGLriOgbpFCKEhIiVTB97FYA/ALBLCPG0ve3jAK4UQlwEa7LmYQB/tqIKl0FN3hqfyzqTuSbmc8gVJOK6hpHpDE7NZCCEFZ68nFPomD0mcnBiAXuGpwAAG/u8otDqLit8d8w1gey54Wncu89qgzsxnXYcQtmCFSa32g7sHZ5cwEY7uLq7w/ANyQasoOm+ZAyruuIYmcng1GzGeXyKroSBF6zvQV/Seg78gqYB4Mw1Xc79L4euCXTGdcxnC3QKkZZHwOsU4iSQ1kMTlU8GK8fEnP/fjZ2Dkyu6XUIIIe2FEAKpgSSdQoSQUFGzKCSlfBCA3wrqNp9tDWPAdu24HUCqdeuFG3qwc3AKh8fmkeq3DsB++UNu3Mr9r/achBDA+j6voNKbNGBowpMpdO39xTHDh8fmcHKq2DZ2YjrtiDLHJ9PYsroTgCXqHBuf961jcj6H/k5LFHrq6AikxCJRCAC+9vsvRcyeElaaLaTOVzKK3k13wqAoRNoCQadQy6NrYtnpY34sNV1SMTKTWXYfQgghxE2qP8lMIUJIqIj8qn+Vjyikvqir6Vx7jk9hfW8H+pIxTCzjFBocn3cWituPTGBtd8Jx4CiEEFjbk8BJe8LZ0OQCbnnmON58/noAwNGxeQxPpx2x5oRLIDo+ueCEzHXHjfJB0ws59CXjWN0Vx4K9OCltHwOAM9Z0YdOAJTLF9cVB0wCw7fTKQqYVPfYEMopCpNXRnOljzBRqVYSwMoWqdQu98JN3uG6keHJkJr14Z0IIIaRC6BQihISNyK/6VaaQuw1LOYUu2GiJQsen0ljbnUB/MrZsptDgxAI29HZg86okpAQ2lOQJKTb2J3HcPqDf//woCqbEx978AsR0gcNj8zg5lcZ5G3oBFMOmp9M5zGTyTnB1V6J80PTUfNZ2ChVdSn5OITcJlS1UIg69tFqnkD2BLK5zgUxaG80+AlIUal10+zWtRBMqN6XM7TC99LN316UuQggh7UmqvxNTC7myawBCCGk2kReF+p1MoaIDaNRxCvU629b0xNHfGcfUwjJOoYkFbFrV6Uz2SvX7CzEb+jqc6WSDE/MwNIGtq7uweaATR8bmcGI6jQtSfdA14TiFhkuCq7sTOuayed9fsCcXrKDpVV3FEfF+TiE3pWLQmu44NvR14Mw1XUter5SeBJ1CpD0oTh+zRtL7NsSSSKMOY5WETZfb4/mT/tPHCCGEkGpJDXAsPSEkXER+1R/TNfR0GN72sek0ejsMbFnV6Wxb292BgU7LKTSdzuGt//oAnjwysej2jk3MY9NAEufbLqMNff5OoVR/Esen0pBS4tj4Ajb0d8DQNZy+uhP7TsxgaiGHjf1JrO1OOKKQchYpUagrYUBKYD7rbSHL5k3MZwsep1DC0BwBrBylTqGPXnYubv7Qq6oOz1UTyGJG5N8ehCyJWNQ+FmQ1pBGo19hcYdg0IYQ0Gh6m2gMVIzE06Z8rSgghzaYlVv2ruuIlQdMZJ0NIuWbW9iQw0BnHxFwOuwen8NzwNO567qTndrJ5Eyem09g8UHQKlY6jV2zsTyKbNzE2l8XgxDw227k+p6/uwsFTcwAsN9H6vg6nfez4lBKFitPHADhj6YenFvCFO/ZizB51r6aPAVbr2HLiTlz3Th/rShhYt4y7yA9Vl8EVMmlx1Fs8X2D7WKui2y+yMoMtxVkfb+qcBEII8UBNqD3YRKcQISRktIQoNNAZ90wCG5lJY11vAkIIrOuxnDZruuPo64xhcj6LvSdmAAC7h6Y8tzM8tQAprYP1S08fwOtfsBavPWeN732qXKDjkws4NrHgHOBPX110J53W24ENvR0ep5CuCazrsUUh25Gjeop/umMI/37vAdy5+wQAoK8zjtXdlii0vgJxJ14yfaxWVND0Sm+HkLDDoOnWRwl/dAoRQggJA2u7E4jrGgYZNk0ICQktseo/c20XHj4whq/e/RsUTImT0xlHeFGikHIKzWUL7hYcawAAE5ZJREFU2H3cEoN2DU158nyOjVsH500DnehKGPjOH1+Kc9b3+N6nchAdOjWH0ZmM4xTaurqY33NaXwdOczmFhifTOK23w/nluiuunEJW+9iuQauuW545DgB2ppAlCm1YJmQacI2kX2EWEDOFSLugJKC8LQpRE2o9HOHPdazP5Istu2owASGEENIMNE1gQ38HnUKEkNBgBF1APfj7y89HwZT40q+exwO/OYXRmQzW9VpikHLYWKKQlcnz+KFxAMDkfA6DEwvYbGcPDU5Yvb2bV/m3jLlRotATh63b2mRfZ4vbKdTXgfW9HZhJ5zGXyWNocsFpHQOs9i4AmMlY4ddKrNpxdBKAFaI90BlHXNec/uOlqJdTqJsj6UmboFoy57OWW09ny2TLoV5T6WofM7TisW2HT7YcIYQQ0khS/RxLTwgJDy2x6u/tiOFffu8ifPk9L8Gzx6eQLZiLnEJruhPos8fXD04s4KLN/QCAZ48XW8gGJ6z2ruWmfAHAQGcMHTHNEZg22U6hTQNJaMJqweqMG47D58R0GsenFjwZRap9bC5TwMRcFoMTC069ANCfjEPXBL7/gUvxgVefsWxNiXqJQglLPItxJD1pcZQG9ND+MVy0uZ9CaAvi5xRya39/fv2OZpdECCGkzdk0kMQgnUKEkJDQMisgIQTedckm3PaR1+DKSzfjt89bDwB458Up/OUbzkZHTHecQgBwxUUbYWgCu4bcotA8NvRZU8Qqub+N/UlnVLFqH0sYOjb0JR0xSDmVhifTODGV9kwz60pYwdBzmbzjErrqtWc6l/fZ9b78zNVY3V0Ui8rxog29uPLSLbh066pl910K5RRaaRsaIWFHCQYLuQIuf8nGgKshjUDTvLlRADDmyqAjhBBCmk2qvxOjMxmkc4XldyaEkAbTEu1jbk5f3YXPvetC5/zFWwZw8ZYBAFYgteLCTf04Z30Pdg1NA7AyJh45OIYL7FH0lbCxL4mDo3OI65rH4fPac9c47Qlnre1CTBe45p79yBUkUq72MSW+zGbyzmSy37lkE75x/0Gcms042T6V0hHT8bl3vbiq6/jRw/Yx0iaoLiIhgLdfuCHYYkhDUK4gd37cQpZfwgkhhARHyh5QMzyVxhlrupbZmxBCGktbrfr7XU6hc9d348WpXuy2w6Zvfvo4Tk5n8Iev3Frx7al8oNRA0vk1GgA+964L8Zl3XgAAWNfbgY9edi4eOThmX8evfSyP3UNT2LwqiYGuON7wgnVY39Phuc1mogQu9/NFSCuiMoVeccbqiib8keih+7SPMTuKEEJIkKisUIZNE0LCQJuJQpZTKNWfRE9HDC9O9WF8Los7dp/AN+47gBdt6MVryoyg90MJPGocfTk++Lqz8NLTLbeSu30sGdOhCeDJIxN45tgUXpyyXEp/+44X4YarXlHVY6sn52/swy/+8tVOzYS0KkowuPwito4FgRDiLUKIfUKI/UKIqxtxH0pcd3WP4ZWf/3Uj7ooQQgipCLV2GJqcD7gSQghpM1GoK64jpgu84DRrzPzbL9yIF23oxZ9fvwMHRufwwded6TgHKmFjX2WikK4JfPXKi/FXl53r3DdguRT+7HVn4Zd7TmJocgEX2KJQb0cMWwO2kl6Q6qvquSAkimzbOoC/uuxcvPOiVNCltB1CCB3ANQDeCuA8AFcKIc6r9/2owPwMcxsIIYSEhNP6OqAJOoUIIeGg5TKFlkIIgXdcuNFxA63qiuOmv3glvvTLfXj+5Cze/uLqMkWKTqHOZfa09v3IZecs2v4/3/JCXLJlAP92z34nHJsQ0hw644bv55I0hUsB7JdSHgQAIcQNAK4AsKeedzKbscSgN3zpvnreLCGE1J2TU+mgSyBNIqZrWN/bgR1HJ/GrPSeDLocQEhH+y1mrnQiaetJWohAA/PPvXeQ53xHT8bdvr+3H6bPWdcHQBM7b0Luimt503nq8iYIQIaS9SAE45jo/CODl7h2EEFcBuAoAtmzZUtOdvPulm/DJn+2usURCCGke73tFbcc5Ek3OXteNB35zCg/uPxV0KYSQiHDXX78OZ6/rrvvttp0oVE829CXx6MffiNVd8eV3JoQQUhVSymsBXAsA27Ztk8vs7ktHTMczf/fbGJ5egKEJ9CXjGJvLYNNAJ5Ix3QmdNu3QoeUC/qWUEEI4+7uvoy4r3T+TNxHXNcxl8xify2LTgDWK+ODoLC7a0o9f7x3Biak0XrK5H6MzGSTjOl50Wi+ePDKBvmQMiZiGmXQOfckYzl3fg5PTaYxMZ3D2um6MzGSQK5jYvKoTd+05ifV9Hbh4cz/2nZhBJm9idXccD+0/hde/YB2yeRNjc1nMpHPYNNCJ+58fxW+fvx6ruuLYcWQSl5zejwMjc5Dy/7Z3bzFunOcZx/8vySVX2oO1smXVUZRYDpQEAorGqhA4QBIgJ5/QRk1bFE4DxGkLBC1qoEFRFDYMFL4L0qK9KJrEaBEjBySxc0R14cJxizS98kF25FhKLGutWLXXOkurw2oPXPLtxXzrUmsORVLDmW/F5wcQOzvL5Tz85uP7rkbDoVMqGe/aNM7+N85x6sIi2zdPcGZukfdtneLYuQVm55fevA5eveGcmVui0XT+++AJpsaqrBspc+NEjbFahamxKov1Br88ep5P7NjMz/93lu03jjMxmnyYwYWFOhvHqrgnnwS4UG9iBo2mUy4Zvz41x8axKgv1BicuLFKrlBirVZgYrTBSKlEpGwv1JpWSsdRoUm80GR0pM16rsFhvYqXkGn6VktFoOpVyiUbTsR72d+un1zWaTsmM18/Os3G8igHz9Qa1SonxWoULi8uMVyt4+P3Tc0usr5aTTxqdnWfbDeOcvrhItVJibrHBkdNzzMzO85H33sjrZ+epLzd59+YJ9r9xjsnREX5r63WcurjE5GiF68drb+aC5AzoeqPJSLlEs+mY8eb8bJ2X9YZTsuTt7I1m8v3hUxeplku8bcM6zODI6UtsmqgxtT55jdQbTtmMqbERFpaazMzO4zgb1le5fqzKoeMXGR+tcGZukYuLDTasG2FqfZWZ2Xne8xsTzF5aYvPkKEvLTc5eWqI2UmZytMJLxy4wWilz42SNV05c5KYN69g8WWP6xEXWVyusq5Y5fXGR8VqFkXIJs+QTmn5zy3UsNZrMnJ1n00SNdSNlxmoVmk1nvt6g3mgyVqtQNqPebLK03KTecEbKyXO+tNRgbnGZDeurHDu3wObJGmbG3OIyFxaWufmG9Rx44zzXrRth00SNF16bZaxWYevG9SzUGxw+Ocet79jA/FKDTRM1apUSR88tMDpSZip8MMfq138j1Il2F7dv3YetyzI8vvKZnRw5rWsKiUj3rnTZmn5Z6x86Rdm1a5fv3bu36BgiIlEys+fcfVfRObJkZh8AHnL3O8L3DwC4+xfb3V99QkSkvWuxR/RDfUJEpL0r9YmhutC0iIhE41lgu5ltM7MqcA+wp+BMIiIiIiJDRW8fExGR3Ln7spndBzwBlIFH3P1AwbFERERERIaKDgqJiEgh3P1x4PGic4iIiIiIDCu9fUxEREREREREZAjpoJCIiIiIiIiIyBAa2EEhM7vTzA6a2bSZ3T+o7YiIiIiIiIiISO8GclDIzMrAl4G7gB3Ap81sxyC2JSIiIiIiIiIivRvUmULvB6bd/bC7LwGPArsHtC0REREREREREenRoA4KbQFea/n+9bBOREREREREREQiUNiFps3s82a218z2njx5sqgYIiIiIiIiIiJDydw9+wc1+wDwkLvfEb5/AMDdv5hy/5PAkT43dwNwqs/fLYoy50OZ86HMg/dOd99UdIgiXYN9IsZMEGeuGDNBnLmUqXsx5uo309D3CFCfyFGMuZSpezHmijETxJlrIH1iUAeFKsDLwMeAGeBZ4I/d/cAAtrXX3Xdl/biDpMz5UOZ8KLPELsb9HWMmiDNXjJkgzlzK1L0Yc8WYaVjEOPYxZoI4cylT92LMFWMmiDPXoDJVsn5AAHdfNrP7gCeAMvDIIA4IiYiIiIiIiIhIfwZyUAjA3R8HHh/U44uIiIiIiIiISP8Ku9B0hv616AB9UOZ8KHM+lFliF+P+jjETxJkrxkwQZy5l6l6MuWLMNCxiHPsYM0GcuZSpezHmijETxJlrIJkGck0hERERERERERGJ27VwppCIiIiIiIiIiPRoTR8UMrM7zeygmU2b2f1F52nHzLaa2U/N7JdmdsDM/iqsf8jMZsxsX7jdXXTWVmb2qpm9GLLtDes2mtmTZnYofJ0qOieAmb2nZRz3mdl5M/tCjGNsZo+Y2Qkz29+yru24WuKfw/z+hZntjCjzP5jZSyHXj81sQ1h/s5nNt4z5wxFlTp0PZvZAGOeDZnZHEZllMPLsE/3U+7S5l2XuXup5p7pjZveG+x8ys3uvIk/PNXtQ45RVTU4bGzP77TD20+F3rc9MPdfctG2nPb8+c2W2z8xsm5k9HdY/ZmbVPjM91pLnVTPbl+dYWXodKHReSbqrrSM9bCfKHhEeT30iPYv6hPrEtd8n3H1N3kg+1ewV4BagCrwA7Cg6V5ucNwE7w/IE8DKwA3gI+Jui83XI/Spww6p1fw/cH5bvB75UdM6UeXEMeGeMYwx8GNgJ7L/SuAJ3A/8BGHAb8HREmW8HKmH5Sy2Zb269X2Tj3HY+hNfjC0AN2BbqSrno56BbJvMg1z7Ra71Pm3tZ5+6lnqfVHWAjcDh8nQrLUxnto441e5DjlEVN7jQ2wDPhvhZ+964+M/Vcc9O2nfb8+syV2T4DvgfcE5YfBv6in0yrfv6PwN/lOVak14FC55Vuqfsrtz7RYW5k9jq6imyvoj6Rtn31CfWJTMeKCPvEWj5T6P3AtLsfdvcl4FFgd8GZ3sLdj7r782H5AvArYEuxqfq2G/hGWP4G8HsFZknzMeAVdz9SdJB23P1/gDOrVqeN627gm554CthgZjflk/T/tcvs7j9x9+Xw7VPA2/PO1UnKOKfZDTzq7ovu/mtgmqS+yNqXa5/oo96nzb08cvdad+4AnnT3M+5+FngSuDODHN3U7IGNU0Y1ue3YhJ9NuvtTnvyF9k266JtZ1NwrbLuvXp5RXW27z8L/YH4U+EEvuTplCo/5R8B3Oz1G1mPVoQ4UOq8kVW59Yo31iJXtq0+oT6hPDEGfWMsHhbYAr7V8/zqRH2wxs5uBW4Gnw6r7wilgj3R7Wl6OHPiJmT1nZp8P6za7+9GwfAzYXEy0ju7h8hd2zGO8Im1c18oc/1OSI9ArtpnZz83sZ2b2oaJCpWg3H9bKOEvvCtu3Xdb7tHxZ5+6lnueVaUU3NTvvTFmNzZawnHW+bmpup21n3cuz2GfXA7Mt/6DJYqw+BBx390Mt63Idq1V1IPZ5NawK6ROR9QhQn+hV7K9n9YnuqE8Ea/mg0JpiZuPAD4EvuPt54KvAu4D3AUdJTl2LyQfdfSdwF/CXZvbh1h+Go45eSLIUlryv9JPA98Oq2Mf4LWIc107M7EFgGfh2WHUUeIe73wr8NfAdM5ssKt8qa24+yNoUYb2Psp6vhZodW03OuuZm8Pyi22ctPs3l/5DMdaza1IG+H0uuLRH2CFCf6Ftsr2f1iZ6oTwRr+aDQDLC15fu3h3XRMbMRkh3+bXf/EYC7H3f3hrs3gX8jsreruPtM+HoC+DFJvuMrb18KX08Ul7Ctu4Dn3f04xD/GLdLGNeo5bmafA34H+EwoXIRTQE+H5edI3hP87sJCtugwH6IeZ7kque/bHut9Wr5Mc/dYz3PJFHRbs/PMBNmNzQyXn75/Vfl6rLmdtp1ZL89wn50mOR2+0iZvz8Lj/D7wWEvW3MaqXR3o8FiFzivJt0/E2CNCBvWJ3kT5elaf6J76xOXW8kGhZ4HtllyFvEpyauGegjO9hZkZ8DXgV+7+Ty3rW68N8ylg/+rfLYqZjZnZxMoyyYXL9pOM773hbvcC/15MwlSXHe2NeYxXSRvXPcBnLXEbcK7llMJCmdmdwN8Cn3T3Sy3rN5lZOSzfAmwnuehZ4TrMhz3APWZWM7NtJJmfyTufDESufaKPep829zLL3Uc9T6s7TwC3m9lUOPX79rDuanRbswc+TqtkMjbhZ+fN7LYwNz5Ln32z15p7hW1n1suz2mfhHy8/Bf4wi1zAx4GX3P3N0+fzGqu0OtDhsQqbVwLk2Cdi7BFh++oTvYvu9aw+0TP1iVbew9XXY7uRXIn7ZZKjeA8WnScl4wdJTv36BbAv3O4GvgW8GNbvAW4qOmtL5ltIrvT+AnBgZWxJ3sv5X8Ah4D+BjUVnbck8RnIE+bqWddGNMUljOwrUSd7f+Wdp40pytfgvh/n9IrAroszTJO9hXZnTD4f7/kGYM/uA54HfjShz6nwAHgzjfBB9iss1dcuzT/RT79PmXla5e63nneoOyTUKpsPtT65yrHqq2YMap6xqctrYALtI/gB+BfgXwPrM1HPNTdt22vPrM1dm+yzM1WfCc/0+UOsnU1j/deDPV903l7EivQ4UOq9067jPcukTHeZGYT0iPJb6ROcc6hPqE5mOFRH2iZUnIyIiIiIiIiIiQ2Qtv31MRERERERERET6pINCIiIiIiIiIiJDSAeFRERERERERESGkA4KiYiIiIiIiIgMIR0UEhEREREREREZQjooJCIiIiIiIiIyhHRQSERERERERERkCOmgkIiIiIiIiIjIEPo/WiTCkrBSsFYAAAAASUVORK5CYII=\n",
      "text/plain": [
       "<Figure size 1440x360 with 3 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "agent.train(num_frames)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test\n",
    "\n",
    "Run the trained agent (1 episode)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "score:  200.0\n"
     ]
    }
   ],
   "source": [
    "agent.env = gym.wrappers.Monitor(env, \"videos\", force=True)\n",
    "agent.test()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Render"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "videos/openaigym.video.1.13263.video000000.mp4\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "\n",
       "        <video alt=\"test\" controls>\n",
       "        <source src=\"data:video/mp4;base64,AAAAIGZ0eXBpc29tAAACAGlzb21pc28yYXZjMW1wNDEAAAAIZnJlZQAANeFtZGF0AAACrwYF//+r3EXpvebZSLeWLNgg2SPu73gyNjQgLSBjb3JlIDE1MiByMjg1NCBlOWE1OTAzIC0gSC4yNjQvTVBFRy00IEFWQyBjb2RlYyAtIENvcHlsZWZ0IDIwMDMtMjAxNyAtIGh0dHA6Ly93d3cudmlkZW9sYW4ub3JnL3gyNjQuaHRtbCAtIG9wdGlvbnM6IGNhYmFjPTEgcmVmPTMgZGVibG9jaz0xOjA6MCBhbmFseXNlPTB4MzoweDExMyBtZT1oZXggc3VibWU9NyBwc3k9MSBwc3lfcmQ9MS4wMDowLjAwIG1peGVkX3JlZj0xIG1lX3JhbmdlPTE2IGNocm9tYV9tZT0xIHRyZWxsaXM9MSA4eDhkY3Q9MSBjcW09MCBkZWFkem9uZT0yMSwxMSBmYXN0X3Bza2lwPTEgY2hyb21hX3FwX29mZnNldD0tMiB0aHJlYWRzPTEyIGxvb2thaGVhZF90aHJlYWRzPTIgc2xpY2VkX3RocmVhZHM9MCBucj0wIGRlY2ltYXRlPTEgaW50ZXJsYWNlZD0wIGJsdXJheV9jb21wYXQ9MCBjb25zdHJhaW5lZF9pbnRyYT0wIGJmcmFtZXM9MyBiX3B5cmFtaWQ9MiBiX2FkYXB0PTEgYl9iaWFzPTAgZGlyZWN0PTEgd2VpZ2h0Yj0xIG9wZW5fZ29wPTAgd2VpZ2h0cD0yIGtleWludD0yNTAga2V5aW50X21pbj0yNSBzY2VuZWN1dD00MCBpbnRyYV9yZWZyZXNoPTAgcmNfbG9va2FoZWFkPTQwIHJjPWNyZiBtYnRyZWU9MSBjcmY9MjMuMCBxY29tcD0wLjYwIHFwbWluPTAgcXBtYXg9NjkgcXBzdGVwPTQgaXBfcmF0aW89MS40MCBhcT0xOjEuMDAAgAAAAjZliIQAJ//+9bF8CmrJ84oM6DIu4Zckya62IuJtAMAAJShQAAADABLJlCWzIByZd0AAABMgA4ofQZQeYiYqxUCV4g4JuLiAE27Lzbd2ClVnjPpdi54CgJ8rKbq/NDvGVdO3/9uS5YLUYzmWnZ8d3qXHrTrmZZCdcWdUr48+Rtf2oP/bdG+5OwwiT2iGf7GMrI+LnsenfYqJ7NNQXN9twWu2vfusHdfe+zNowRsdJeFN/LhSjTWWQDkYwAydQpTZCBwrL3lRxtKtPOU8xCy3sfNtntRtGBsjswrSJ4QA3P2aWakDvsNc1Gn8/R4xbPHVoCc0D1J8DMzZkIWsIePAMaKzuJC6REMW3XzP5PFuzPsW1vn2Cm2zWtvtg2kCgLnWqfdNPtfAyvoRs3xPbgugyi6duj90Vrm7mJUzUC9roXh3foAVOwACQwW1BPqf3PBCnew7mVt2CaDFJVLH62DhpLSQieuPXFSwI+n+j3PiYKs0yMOhBzl94pDma9KOllPiTAPYkgAROGIL3F6PX6MR2o9XVBQ6uR3OZxreDDN6VooNGan6//bDKViuJvLCKv0zAT43VUs1oYmP6Lvbz4ObvtptKO7VFlXNRon3IyeHFcjHabF3M+B9sYgAQtOFbGdsZl2PA4OSYXIjaNT/kG20meKhz8/9DSAAAj0oCpOZ6bNefs/4cRlE89k6M1J2fqYW4zHswQ7iyuzlFF/0ekVBBXerM+m93ZAKgPth5YVsAAADAAADAACAgQAAAMBBmiRsQn/98QAAAwKfWDdAIQ4cIDwmJOnHNsT0I39XiA4Fu5IalAYiYcn9FxhEzRELq9U6cPAXCbRKl/gM529/s0Mx+oQgHI5SlrzzttbttSab/w7gb+O/ZmJnhmBf+9m2EiP2dSAciC/nShAVdl+O7PzhCKkWEQFTsamvwasiifwma3XrEM7IYrhKzJZDI+DXgEkJS+NkZD2d53Ec/sr9Lo5tPMbL2c7VILdq2Tvi1H6yAAHRjfXzxkQNOLLyOkcAAABdQZ5CeIR/AAAWI0it8RnMvUHCv8rxJ49P0DhdBhYPKVVLB8i2IiyfmgxHSACDxdBybCEGcHyfod0FiQPB8xwpg+oQZkljLmop3zvUVK6+qJ06oEOccAB/DZLssCyhAAAAMQGeYXRH/wAAI8L2YsbWaW9XwEvPVz+dNR/XNLiTdyjyovN9aHKM4AAAAwANIBSwHdAAAAA7AZ5jakf/AAAiSs6MYBFpPOxszuZ+tq8s49bwfeDF3R+58C47Gg1uW+/fVM7o1MgAAAMABJ+4wcqgH5EAAACVQZpoSahBaJlMCE///fEAAAMCnvblv6tu2NRib4Nog4ARTlDZLJ1nevXfV+wbieduf29EUR8hXobV35l3WZMNwbcRlUgvODOswZH/AzdBLd1LdIR44wMxnpDM0AeROFFXzXVwSbuT9G6ZCW9Z6J6gN9mCTjE/fRvhd0xu/wqhqDb2pt2M93Pxj+JCtLh4JIfXH/1ANfkAAABJQZ6GRREsI/8AABazR86tzMdlkMnaT/l2mKgc1MceFEut89JOVKQ4hmMuxzFD+Cfa0rE3Juc7cN/AvXll+z6MR6RfTtGTleGTAwAAACcBnqV0R/8AACOr+Fm4hcicVxSxScXLghWrdsuOVy+ztIxslU8uCzkAAAAuAZ6nakf/AAAjvxs+h2Oxw7usY++lzAoPVXN5CPxj4GgNBe0wq6SA6TwGKDlVKgAAAGVBmqxJqEFsmUwIR//94QAABBZJFm6IAofvnRsJNZnX2utf/POpkk+j5uagEylcAlHtOLjYjNYe/JIbjixyIMGOY6yhm+3t2ZBNRnOOQJQO1dHbs2d5KCtiBk9wiEFkhp9hL2CScAAAADxBnspFFSwj/wAAF0xDFqvmaRYFPeIR+gBU2/lsbLzVYQwp0vQ/pE4y+BFKIuLCXm9JefyeuQCPv2UmTFkAAAAtAZ7pdEf/AAAjwzv17VwcUiF6Ob8uXAr7LdS+kjW0sQsT02jm5YScDGgQpuzAAAAAMAGe62pH/wAAJL8EKoiJOnTlCSj3ZMLA4vADfA9znuAt6LJcTApk80jVCWUdWBROwAAAAGpBmvBJqEFsmUwIR//94QAABDuiamr6DH3h7Kd8+1r/PmqFp45n+fr7sqgYHBg0WowKU8fLUYysoAdAJD1cbuKwOW8p5SsUoNU9yUJs6YKsYEsXlprUH1bf7pI1A4LPvw/ac6KFGDb+CvpxAAAAW0GfDkUVLCP/AAAXRUwzgA4gOl5u82IJNb8XJXvBZJQhVEtQ3eL2AdMNLBQkPCDoeV1fvPKigfKRtJctlhzy66yhJqi3rJI9bEQGinaEKA+XfrWBapYwrfMdl4EAAAA3AZ8tdEf/AAAkuKlWNN68EITGPDmamvc6ge2rkegGZTvKLbYYNcwQ/DktfQh1XvuhN5Za/vKmVQAAADIBny9qR/8AACOuYEE0EvQMqFFaO0Tk8AvyJRRlHef5yw19z9mEpaJXQ9ahaia5qVEUqAAAAIFBmzRJqEFsmUwIR//94QAABDM5tm8FfkgUfcrVVFeA4tcJkrVhnmjaQ6HLw8n2E65E6YXv8THx697DLterV3UbDBMgnrzX/yJOiWYpynpH4mxNGRAmjNIDmiWapnk8ixZb0Q/F6rVr4RAKjtq/f6XlIw7EfuH0EfFbjuRnQI+gG98AAABbQZ9SRRUsI/8AABdDR/txIweVkJIkXxt5n2byLcMHhXCcqJbt5lmZ5mTj0z2O3otjS1M36nOPP9/o5LYNnJEfKAAmajGxJBmpsWsvAo59NNBp2qZCTRSmF6hEHQAAAEcBn3F0R/8AACSwq3LUjAKWlIgQKvD94wnB8AE0xR1ud+xZARGIY26GgBJZ9fG7UHhBxRTsE/MIVargWGc3f5CGYdR63sXSoAAAAEABn3NqR/8AACS/BCZuz9NovRgYdwmV3yFnxwOHJAKZakotACSzvPxfsfhIsxAkevhkRKmcn4SV4mUc0qZpZmVAAAAAn0GbeEmoQWyZTAhH//3hAAAEM1u6mG1KoCfZJqlAgE+eeINxv+gTAePpxSJJ/ZW2NrKWdkJSs3qal1L+zSM0rcJFcACpW54DIBHW4CCQXi/FyblhRW+Tx5BLU65k/e7zkzA22isdt+j+wZmIDq2RbnhL4nWJARy038vjVXE52MfOZ78oFeM/2oosxoooZe2t0IfmYYjY0rXkaiYx06qjgQAAAFZBn5ZFFSwj/wAAF0NGzrkOWVyFAkVcIugB+PwCJDkWrNgi0kUW/dLLuI7a+vwrQAqd8Qjcb4CspWlepvTLejvZ+Cf2ocN+cQMWJ44bYlqGABHpNZyTgAAAAD8Bn7V0R/8AACTCXWwpCuvMVxYTcoKdBub6O+yovQPOJ2aNnX9UTB0PVJwaTKwMWeI1/+NRy7tC1GHhV4TdgUkAAAA6AZ+3akf/AAAkseg0feYMRMlbLuJLo8urzg2gAgCF7LhUYIVa8GAPv9ABKdDq3SRJ+9KylFtwIyEqKwAAAElBm7xJqEFsmUwIT//98QAAAwKw7RzefMNaCSwmYA7+o9scDWHSAu9JUCW4rxdf6cnSEVJ/vXG76jeaj9Mqk4GHmbaqFPNAJS3AAAAAVkGf2kUVLCP/AAAXTmAdSqQAjAak37k16UlnlMoPw/lv9kegql9jSpXMUTG9Sxh4qIpHdT5/Oo2tqq7i0A/u6IPIGOggEG+aASI1cNQvj4lR2A0qJo6ZAAAAMAGf+XRH/wAAJKnqU7tco2zm6pYYmadtPP0a2RaPCjvMeUxU4pnhuBSkDvPWDtBNgAAAAD0Bn/tqR/8AACS9gy7PhqBdRlc2ItGvzkhSHZSigyEfbxUDQAIOryg3oQ5yWmmhyqAwxEM6acqrjwivh02BAAAAaEGb4EmoQWyZTAhH//3hAAAENLYEOhgZgeE2Ef8IpdOD4rARJ3ehElomg4umAAYlNh50SjEnusfqRT/JJggaWVsaZGjJ8NZIXpzh61lOuRX+hRpQyAv/qEZf5ldoVbNSWXwGN8b82iKBAAAAT0GeHkUVLCP/AAAXQqwvV+VTYHEr9tEtxwGLPXd5DIIsfsDCbGSvA8elFFALY7cx5EGN1x/UVS8nF1DXyj+yMIuhVnrpsQcWsgLoMuaBDugAAAArAZ49dEf/AAAkwJkfz2WEtG7oDR/pizpamaLIS9p9Y2RLcFKtaGkbFcpSVgAAACkBnj9qR/8AACSuX+7mRmsi+5HGtzq9KFC68AoUYIt9OqvD4wH8E//qbQAAAJZBmiJJqEFsmUwUTCf//fEAAAMCsyeSmN+3rwByiexGRqmVvbiBcoaYzJA0V4bcR3RTa7XTlIsoKoCgWrHl2dn8vfywsYyng7XuLS4aOCi+IbV2kzibScpjVReKE999DvqZaNrje/lZtJiXn4Gii8kK19GQXssKNbFvddZzg5Th8frG9fhCmCgLIFToMCi/PB5FWV7qU8AAAAApAZ5Bakf/AAAkvxs8cAw/66p0Y0gGx+qgyYdBxuZYASUu+1kjB+kzHuMAAABJQZpGSeEKUmUwIT/98QAAAwLC7sUb4ChcYnxWGjkCQnL3ZTQv5Kb2NZw0JVXc80KuJ8YmXwOhhe8Vmrk6f2bQLLvUvtwVYareOAAAAC1BnmRFNEwj/wAAF+mC7bAEHYwNN2cpzyKsIBp+fOzzR3kJtrK2YUw39kqhXTkAAAAxAZ6DdEf/AAAkqeru0T6qyLwdnIQ8AEsebf3nVNt3jqLANdXVQX7WDbrxPkVahJ7J3QAAACEBnoVqR/8AACW9Jr9UgubQJCSlfXyMls+MH7UN5QonUg0AAABMQZqKSahBaJlMCE///fEAAAMCw7kNtEQAKDXL8rKlNyg3GqCA/UY6w/2ePR7K2w0MdqCRZmJmURW9a+eHhI/qcwW8Cdlbyu9TqxoC0QAAACRBnqhFESwj/wAAF9/r6LQ808GL5sKnrunBmQztS3p3VmrZVJwAAAAhAZ7HdEf/AAAlqf+GXKEMRbrnx4DC9IWrirkJPahpiQO0AAAAIAGeyWpH/wAAJa5eM4F5Q7PNtkBlJyEB11ybhfIsVFnxAAAAiUGazkmoQWyZTAhP//3xAAADAsUmUpqvglAA2k56Swn502SCld+ZLU9pZfs09zHfbXmpLEZ+Kb85m8DOCb7q5jfMmKMKR2YDcbUWVe58r4RThHJA6k0UDUuFhamYBmhTzk2F7KMsIjEkSi+AwpLyVGeKBhT4aNtJtSBlpVYB6xcYNiI5W5GkZdEMAAAAP0Ge7EUVLCP/AAAX13pIGDeQvyRLqX22xVp++lcgA/I3kNryZmYhbKFIs6bwp86qIiMwJyqooTOthJjc/SjlAgAAACgBnwt0R/8AACWp6ccThXQ25K1m4m67ZzEVci+faINPOy5ezRoJ3sWBAAAAQgGfDWpH/wAAJa5e4nlib3hUYeJTVCsqTuP0WSf/p0gAW7zV0yvliDC0P0mM5eLqnSqljE4boa3vfzKcYWFFmr4xAwAAAIJBmxJJqEFsmUwIT//98QAAAwLC7R6P1biW+rKABOqjDxUe7V2xRIFmalzOuuF5UN7X1BYpQ10AoBqBX7de0LevFRqbH4OkOKj9PHj67ZhXF4mw7WPx6xtJMfZDKiSOsO3uh/0Vj2YWp9wV3Sh8SvAZj/7qfpQg0rYkwgYk+wev8n2BAAAAOkGfMEUVLCP/AAAX3+wvTlzOmxTK+UdIAK2dhEx9vA8pz85Mo+ENW5VkW5ec7y/dA5sIvgWXObJp8kAAAAA+AZ9PdEf/AAAlqenbRscPwK/e155/3ReO+OAFkIzNhrvYQ5HgSDw5mOad3+YJrX00o2Byyw5/1uWgg9qxqgYAAAA4AZ9Rakf/AAAlrl+6rQqguoIR3mjk/Fq3cJv3+fok4p84ABNHZsfAgoVUO5vJF05ADz8XKKRRYfEAAABnQZtWSahBbJlMCE///fEAAAMC1O0X0bWAZzcFLDsZSXGi07h4E6itOQH64YGjWC60iAFwg3xaWU1j4zEIQqfhDVd8ks1oInv4ClixOYlBiymZ6AFtJCU9Rqic1FU+9WZ16djmTn+u+AAAAE9Bn3RFFSwj/wAAGIl8w2Af7i9jzgRgrd+zUOE6hb2N8+UvfDqPm/Xh9tN3cGLABOMVTHlorF4Gd1RGaFbJpJE6aZyrCq3p+6sjT0ZMoZZOAAAAMQGfk3RH/wAAJanq6OqPkn7N5yOqzQyjMKbrYIAca4rTeC9vrOeL1NR5yqpcvPdJ5ycAAAA7AZ+Vakf/AAAmvvU+GmQ/GzsZpn/Yu56IXYy0IfmP3Qf/gG7akSgAg6oPueFOytFqPLvvIgj+Db7KJFgAAABsQZuaSahBbJlMCE///fEAAAMC1OsIoAKOVfoRZpNA+VHQmgMo+Bbp3OzJYPs/l7WlaDjuwNv0wB97I9Sg98A3dOLl1B9QgSeQ236I6kujs8OtZZ6/IG7ijPRgH7R72eFEXZG2Hd4lMFZN7Vc7AAAARUGfuEUVLCP/AAAYiJtupuYO7/voXd4dSBD4WzLDslmk97gBaiGzTcGHjDDYqUbtnkr+RiCVUYAivoz+V5t4XXi4qEh7oQAAADkBn9d0R/8AACbAmJtJF3wC0iud2wRtHftdzFLCf8tT+ZUcr86x7QugAejb/yBCV9x085jwBSrDix8AAAAwAZ/Zakf/AAAmrnr4bL91CLHWDeyDMVk5geBZN2gfJdyaAMT9VwMMmVeWzsSeXf/dAAAAY0Gb3kmoQWyZTAhH//3hAAAEd6jqB7gGZB110UFc6LTQZGl8o8iMI3+r6TWbHe6//sxD/lOoY2vIsnvqlQrRlYBqVqhJJFeIWxK0qy/wcZtFxh4FxMeycK/qoFINSczqWPSpiwAAAEFBn/xFFSwj/wAAGI1wuGItf0EdRaiKjGazkepJPRaKwEyrEPXtW8taNgBbxszWP1InuTLiG3Jph0z1fP0oymeyVwAAAD8Bnht0R/8AACap6md0hS8gAWjPm3eelgKg6aVxOtXs/w4kPHRdSWANbEp7inS2pTwfWit6j5pXhkcHZtq2jAkAAAA+AZ4dakf/AAAmvYOBybrjQJFynDKFqKdoG4Sd+cIPkamwdNhf84ASsCAAnGcE6bNnB/3+sJNE3OQXGqN0KDgAAABXQZoCSahBbJlMCE///fEAAAMC13cv4KCO2LNUpqTu0sHYX+drXQODm2mxQMSen4gaIU9Q2IsK5dl3PEd8sB1RTcAp14fJK4kVJeP7z9mMfbvwhqJSe2BAAAAAVkGeIEUVLCP/AAAYjXC4Yj+7cRd66BATQVM7LP4GsLOwdExHTBSXZbOn5CuaUSeC0wRLqFNQrIZJilCpIlQeS7sW6Y6l2442F3Ku7j+h1hybB4yVaYuBAAAAOQGeX3RH/wAAJpK6sYqNhmo1e02/HiAEYCk59C0k6mzwkzI0JqO3BYVPOLwd1TFo9g3sp6A3A6H1lAAAADMBnkFqR/8AACa9g0Jkzo7JjUFL/7atH1KZWqRxNw6pj7dn+9KYAPwFq0kQ9bHA+m6L+d0AAABiQZpGSahBbJlMCE///fEAAAMC1OjYgAOiyU1dOS8aQyTxG40QI0aY7dsLi43t/a0l98/5f6u5mjDvM5xjP13KwJqXO9l1ZgzBozcK531fUmyo6oxtHhnRSMJ+Y1o4cQwEXvsAAAArQZ5kRRUsI/8AABiNcLwZWLUSOAJ/Y4Khpw8EIsXytUZY8jtf9Rs/wUCCpwAAADMBnoN0R/8AACap6vQSuhwAXE+hqp2kYjawaqRBeZ7h7IvEVJttxbF71UrgTUWSHEvlE48AAAAvAZ6Fakf/AAAmrl/7N+VmTcNEdNfjUyVgBb/KhnhA42IC1Cr/xOopJ0bgeNLwJtEAAACIQZqKSahBbJlMCE///fEAAAMC1Pb+wAJlsBkAQCMWrvJ0O7PAeGCpjOi0LCy7Zz/37oFX5OiFE2d9aq3zHyjD2D90NQopbArXcNHFz7TJtLBCpU3MbFdALsYqWiBcaCTkGWl8FQ+SBqHj7V3v9Z9r9TrexddNoWgpXbK1GLGFS0XEJz1QxoahmQAAAERBnqhFFSwj/wAAGSl9LmNacqfKLOtAprwAH7cfVgdOSaGi3p8gEAcrWUGWZsBw4Oed1WXJ2DfG83NlflfDM9tlc6jJtAAAADcBnsd0R/8AACbDOapMsALH+4AYE1z5glsAx09F9j5Ywc9S9qcHndY3xa4fVbEx0+BJXvW1extAAAAAPQGeyWpH/wAAJ9mEs9g6DABI6sqhAN4igkcKvz37/ZONhQQNa1GYumadXRMui4RoCkE4qJlG+HamtCmgPFkAAABaQZrOSahBbJlMCE///fEAAAMC5ujKYG17ADMnTE4fysyjpI7OWyBxHbCYTxAvVyjOSBv8U614O1Ad2BZ/9Nrab1bGV1gsoDeCRh1d3yB69CZkz5dT70nsx/NqAAAAQEGe7EUVLCP/AAAZIIdILXm3AABx8OmvH3tb1IJ8kw500IpzIpz+AruytfVMS/IseyT9/8jQv9ucQg2UK3OGNoAAAAAyAZ8LdEf/AAAn21cmKFbKVEpeR08ARMAheN9iScg5hV+N9KwPY9JXCPFQZn2FA2W7cG0AAAAlAZ8Nakf/AAAn2VK9QHxkgAprpgBJm8fsZBIFzDsjOUdJ6FAlOQAAAEJBmxJJqEFsmUwIT//98QAAAwLn7ShalS8BPvOFvcmofgiwLEFRkfyuvvGcIuRPaxneAFP2ULX4iKvI5vgE6d2H9aEAAAAzQZ8wRRUsI/8AABkoypRkjWMe4eeg1cGDY2dQ9YASvoAJq6Bs6Klno96UVz7cEXW2pimgAAAALwGfT3RH/wAAJ95J09KQL8AEqFUSo9+qUqEO/UZFDvnAaq6ZQNZ7k05aY4wurAR8AAAAJQGfUWpH/wAAJ9luOIP7osuLjsjaYwqVyr2K1S4C3ydFw7YwdbkAAAA+QZtWSahBbJlMCE///fEAAAMC5vbYZ4rfiMPNRAA8q1QuTEeO1dYG1kP0Jf+ckVT4GWFyKjVieu0z9ILUGKEAAAA8QZ90RRUsI/8AABkgh7cNuRwv3Qg6a20tXZarWIKOTmBxFFlTANZaaGY7YBAnaB5LIrmU4Ou7GiJy9XaoAAAAJQGfk3RH/wAAJ95fXy57wR3LQroHdtCU8x+TCB0R2rcHlvBSy4EAAAAjAZ+Vakf/AAAmsjyvVEneS5Q7SplZCd4qFQIfm3A1v0iRy4AAAABRQZuaSahBbJlMCE///fEAAAMC5vbeTaEJoLMAAtmze+3elUQADSIoL+EjKs8gJzRPM8eEagDRDupQ9+wVby7KEHlrMlzR8Oafu+6Ahe2MQqCLAAAALUGfuEUVLCP/AAAZIIe3DbkbQQb4BqJogA/DwCMLsDcxMXBVLgZRT9hjRfdjrQAAAC8Bn9d0R/8AACasQlQk/wsaCowhXXu/5toIALif3KqMa22PHcoEB952kDQ2ixMjrAAAAB0Bn9lqR/8AACayPK9UeusubJq9jeAyp5jLjs+NFwAAAFdBm95JqEFsmUwIV//+OEAAASzxhn6AQefJWg0nCFRIolvYs7jjQMZylC59UTd1cK4l2uTDD/2Z4H0uEwQeD9ZH7TyFCJiuZyhYMBY/0+4hMfGbrXWhiZ0AAAAnQZ/8RRUsI/8AABkoyn5dtr/A2TZwjJhy8IRYypw54qOO5RpLjRthAAAAMwGeG3RH/wAAJ0DvOemD0L+1pYMxlNBLQAtHmrplfLEGFofpMZy8XVOpb6XRKwZFvt3R1wAAAB4Bnh1qR/8AACfFVeHzp4X+Wx7PFbUMQ9gSRozkx1gAAABLQZoASahBbJlMFEwn//3xAAADAukYXy6yDAsIcZ7gbPqRbQ3VYEe1g9S3JHiGXH3iathhklwDJBAHqwx2A59xYUmlvjS/gI9nGRrQAAAAKQGeP2pH/wAAJ9mqbeGHl1gXUOQzhCACdYaHA1nbSGLmi82RKqoGUAbRAAAAWkGaJEnhClJlMCE//fEAAAMC5vbmmnK3eo0xTgJABCHQ9N1wknrappOzymJFBWzmn8PmFU+SXX1WAzRRhQQCs8bq9t5s4rHkmY9Y1YL2HJx1Roh0QLkVC5huXAAAACVBnkJFNEwj/wAAGSCIi98q8M1xZY5VYmcbU6APpgk9X6TRb7ZtAAAAJQGeYXRH/wAADtRQ80ldC+Z6zw2VwAJXHRcsoZ70KrgUqOpBPgYAAAAqAZ5jakf/AAAn2aXDdgAkcLfR9F/VAelKUWW4R0jDqLdGzUgZD1pdayGVAAAATkGaaEmoQWiZTAhP//3xAAADAub25pp0PwE68sJKIQS4sFHFJnbRZ0Nz1pKUxHSdM3lcIGFuxytp+JE6hfrfj2+rvbeDHO2nPV+kEaZJwQAAAChBnoZFESwj/wAAGSCIi98q8Dph9SqVD6dxiMQ8qAAbnMuRVac+0Zx5AAAAFwGepXRH/wAAJ8LbzJYaQDwanj/JIJ2BAAAAHAGep2pH/wAAJ8nzBxM6jcI6GdeTtQiag4v9M+AAAABgQZqsSahBbJlMCE///fEAAAMC+lbd3TwSmquXimuYtumo9lkIrrXUAFJn1LVjlqYKAoPx1hRTJtL/EGbbF1zVp/hdCuWkBgvS0GbeDXdQ8tJNFC0D8S9DVbnVgltjHecIAAAANUGeykUVLCP/AAAZwIe3DbkcL+XQjOsAAODFJolEv3jqvnEeXJ7bpzw2i/nlcBmQjudgrLHhAAAALwGe6XRH/wAAKP5fY7UoAIphDm3xU1imvXKPtm95uCa95HZa1XRItsDUauJZQCseAAAAHAGe62pH/wAAKOmAcNyg1xcfSOvHtwX4TAbEceAAAABoQZrwSahBbJlMCEf//eEAAASzc2QfkgU8lYWSRHqMyjehwnFw5CWNO6sxpQrcR/KEmWC1Y2IPsaauUHpIDJWtUrwGnp91ccRp9np4ldWadOg3/jr56rwO3kC53Yp/yRZU53vPh0g0iyEAAABMQZ8ORRUsI/8AABnJfS5Wm1HADbRti50b8ZW0SIXERxV7XEdPXgnPmeCOsu728E7LfMd9M/rxdsV957/RGrLRXyFR4Rx8LhZK+iMsCQAAAEIBny10R/8AAA81fHTB7gtcJRfAASoVWZWtyVTe1d8OlQWEgJJrCyaxQ4s4P2nS5TmYzAAOT1SUX+TxjANj/qYjYEEAAABAAZ8vakf/AAAo+YS0MP/ZEhV8FaqUCgBU8EJhLafL2k8Y0QqHa3YOGw3KGNl0U9dWW6zUQRJxnaOR9xmJz9Se4AAAAFlBmzRJqEFsmUwIT//98QAAAwL7TJ2XAGb5X6EWZ+6kdQsALyMjr1L7bqr2dYMAqX5gn5VsVPP8bNFcn8qTAAYz/dbPUSLU8Z690GbxjPXJp6+fiiVGN4O2gAAAAEZBn1JFFSwj/wAAGcCH+3F8e+Qgjrb/BPLZcBBAM33JVtqNUyndQsh2E3xtbsQs3T5XugKruDggCcaA9Hea0ZI+Z5Av02PBAAAANQGfcXRH/wAAKP5fY7UoAFxPoapPCArmTigtE0HpqHSEcrEBE95ds7tZzVMJr+8Qsglm/T3AAAAAIwGfc2pH/wAAKQNmg/9FSpd6IGZ/HAGRHSKuwCoszWAgeKFgAAAAWEGbeEmoQWyZTAhP//3xAAADAvpi8OAiUllz8aGzCVYzKGXQs/ujLPfXFxdCbSUVSFTXjCIpnnscMier53KoYGyJz28SnLyXE7/uoKC+AZRfLs7s5CbkyEEAAABAQZ+WRRUsI/8AABnLqd17uq2G46BAKsnDTOudNuEA9HFFXoOpvpYg+EBJImP0/G6ul7tqduMPb6IAp+A0L6bAgAAAACwBn7V0R/8AACj+hggHQUwAJHC30fQwl0IQ1l4017srRHW2fZqfCOIeiHNjwQAAACoBn7dqR/8AACjpgKLnw4wd0gAWjPnZq+lB7ov+37s1C7TiVJZibyAXllEAAABLQZu8SahBbJlMCE///fEAAAMC/EKlrwH+dNpMBdsXH+iSgijyOLAzjfIg47UTlJ0uw38nja8plldORfVsGqv+uBDWYn/oJr14yBQEAAAAPEGf2kUVLCP/AAAZyMp3jQpI2EMCvUa4ekR5992V6onrwA03zNkmLYwgaoURcynRHs9QP07O0x2Aotl2BQAAACABn/l0R/8AACjwt6UDZx1J+5I2ZSTFpq/Z8BIY5a/HCAAAACUBn/tqR/8AACj5hLP1qABbdXwJ3k/LMTuQpMnkBMnYJymxEFCxAAAAUUGb4EmoQWyZTAhP//3xAAADAvpintq6e8iH/Pp28oa7yvkfBkXiEtNSdSuehytjAgYrH4IjfwsC7C1p7qk74CFPtv2AgScR7Domeg4JM4hJ0QAAACVBnh5FFSwj/wAAGc2WhYEjlGgS+jccXVZIPMyMgE7egBN1Zlx4AAAALQGePXRH/wAAKOLiWd9WzWvFk4QAXUS4OF/IQ2I3QwQatkoEMn+GwaQV2CuDKAAAACYBnj9qR/8AACjpgHDcoOKAywtI5IhFAB/MX5rS4yQM7uVh+CIfcQAAAHRBmiRJqEFsmUwIT//98QAAAwL8j35k/0AbY/D4rESDqvlUeoTQvsihJZc4BAw5JMHNXANqLQ+TG+xMPPn6/NqlbzqG9c1vKJ4l0iYZETvjhI/RbAIfgcbYdsUu6dkOl724mRGuM0DrkWXhly4DdGEc5pjPSAAAAElBnkJFFSwj/wAAGc2WhYBdt44AFojbF7lE3RPk8eDYzT76lBpp2TB0AtZ5N1uDM152HY+K+fY1y48lzamxXcq3u3eu9p//b7OfAAAAKAGeYXRH/wAAKOLeIXwC7wm2AALWYS6PkhWOUWSK4YfJX5+TAogAefAAAAAtAZ5jakf/AAAo+YS0Lu13lNqjn503aSsBH03HQRCp+Xf7kAAJX9V5BMRqHzeBAAAAaUGaaEmoQWyZTAhP//3xAAADAvwXFOKTP4ChLdtVRfOSiEavSq3+4TroIA3/GdlmN2yWIQBdTCbE6rN2x7WtAE/+2Mm+uscF6kFb9RBBt5KR4tkfE7sruO1bRP5TLUUieoVmitU8cIS7aQAAADVBnoZFFSwj/wAAGbfl/8rPi9vsxKAKi6BtXi3Vlegx/e9gGV+2Aq49BsN7Q4nkC2KyghI0wQAAACgBnqV0R/8AACjik1MNsZhmwAFrMJgGBIU+YCV3XJYTaMj4QEIHMjTBAAAAFAGep2pH/wAAKPeo9KAOhXSXmYeAAAAAN0GarEmoQWyZTAhP//3xAAADAvpi8OAhjS6OJDqc4WcmhzyzKhheZyGqmVycfd2lOp35FtbwLAgAAAAqQZ7KRRUsI/8AABnChAVGJSqssEOFlgAnGJYSdnQ5LV6UwWJflwmTk3PhAAAAJAGe6XRH/wAAKh44F6nLLiSwAXE/waIB+5fHPpYyrUB02QjPgAAAABsBnutqR/8AACokJBABTxFdcW2KBov7cBh4qNMAAAA5QZrwSahBbJlMCE///fEAAAMC+mLEmGU8lNgLF1bU4lMSr3PHn8vwsAQ3hlpwTVrK110Ad4GaTr2BAAAAK0GfDkUVLCP/AAAZwphVis5FmMAJphAep/EDp5DtNvOeRimxL+AIQHHkMoEAAAAbAZ8tdEf/AAAo4tkq2QAC6iC395HlrYkEREELAAAAGwGfL2pH/wAAAwDS+2jGBUvAd2zyF9DbGWqrUwAAADVBmzRJqEFsmUwIT//98QAAAwL7Td8FDXlH9TxJQvodAVVUpB6ZDBWhG/1iWtrTY2tu+Ghq3wAAACpBn1JFFSwj/wAAGcKYVYrOZsCUAJaZ2JYJYfboVKkT9WQ30wARTwqRKmEAAAAfAZ9xdEf/AAAo4t5rBwAWn9v3Ge/qFN/eKdoSdCB0wAAAABsBn3NqR/8AAAMA0vtoxhYi6sXhTNp+y0W5SYEAAABBQZt4SahBbJlMCE///fEAAAMC+lcZugCg2hAzovw1lVY2gRnOQRcu2UbKdRbVmjjRQUsWp1k+D/cFcyiq7GYeUbEAAABOQZ+WRRUsI/8AABnAh86v/XK6xKn0AE6nyu7LP7sAeFojfd4f8lnZktap6kBzxu5BcZmAQB4FwzropRbqiWl6OnTH1L67PWdgDggB9l+BAAAAHgGftXRH/wAAKOKTSOoXykkqMWOIYFIHWIbxxuHnwwAAAC8Bn7dqR/8AACjTOkWmI9fK+3fABY/299TWuaLXmDbemtghweX8T5Ak8KcJPX4MoQAAAEhBm7xJqEFsmUwIT//98QAAAwMOaIkCkH/iIoACxqjEHeQOtuKbdFNQfWWUMJHEMOzS0qTBZeIniFskT4/u7zzttf14oG16MugAAAA4QZ/aRRUsI/8AABofvBx+FtlXxbYAEzUC50JJwIz/+jFL3n4ivpmBeNUJ9absgcXwl4wc6ELoe7kAAAAsAZ/5dEf/AAAqAt4dGifG4AC1EbhFAbwv4wNgdLUPrkwrLWZiMNzQcLZIwcAAAAAtAZ/7akf/AAAqGPoQeV4oGphRqIASqUHLVE5kmxnVEWUXsARF3gx77BPSsGSBAAAAdEGb4EmoQWyZTAhP//3xAAADAw8dZ/uoaALQ6c/AfCXCmAGikdlaJAhkBANB6+V8S9W9NmBFslr4hNgUIJ3X41slfUvXJkWDKFw453oan2223Qm159F34GBVuluxL+P+OUxTQl0JlJnR5SrdFv94hfeb/eyJAAAAK0GeHkUVLCP/AAAaYliP+9PC5QQGs9uZpD+QCO4xWljUSC8+Xec4CM6j1dwAAAAnAZ49dEf/AAAqAtvDNQ8TESxACw9Cn7Ch6iBXfZhsdtS0shAWkaXgAAAAIAGeP2pH/wAAKPmpI0Gq4jLADQiIu78858LC7HED3SrvAAAATkGaJEmoQWyZTAhP//3xAAADAw5W90ANWG97M6avUHpS3zCA5rdoro1bfmyD6rRT72z7htoM3/4wY4x4pp3cchoRep4q4adapD9K8rQUvAAAADBBnkJFFSwj/wAAGmCIKeDMUM1QAltXoojvWTv/wkhwILCPlh8OiZWBACV8+smkpoEAAAAyAZ5hdEf/AAAqApNNhCnLyKuQKIk1/L1YGdAABtcQv7j62IZXu4zKYSxxB8rpKmwLjLgAAAAlAZ5jakf/AAAqCYBw3KscAButL52ZYiPELVz0Qk2edHHqRmek4QAAAEFBmmhJqEFsmUwIT//98QAAAwMOYvDgIY9mCd6eJotCDfg9t3hg7NMKYLNScEj8zMjg5pjH+VWTa72hxBdTfqwr8QAAACZBnoZFFSwj/wAAGmJ3lt7aVge2wcStCuhBfYYU3yVeUFN2VlY1QQAAACUBnqV0R/8AACoeSjE+ZzmOKuxyzifaZjyLAA2J9E0kC++qEgmXAAAAJwGep2pH/wAAKPmqfL4V+TzrcQAXE/waHiBlPxbP3D4Y9Dr+HBGDPgAAAEtBmqxJqEFsmUwIT//98QAAAwMQQp1gezAItaAjydjZQo1iPrM60LMYWxk27e9nWLRC1u+mWEcyqAzA21RaYd7Vnk0BehwX9WKXoTMAAAAfQZ7KRRUsI/8AABpgh7cNuRwv63JMmTkmfSLFeeD67wAAADABnul0R/8AACoCk03s8AEsfsP2eb6iAt0+2Oi4Er6LcIIyhzzM6IWQwPdDenr84cAAAAAVAZ7rakf/AAAqGYSz3Elpmrk5AHdAAAAATkGa8EmoQWyZTAhP//3xAAADAxIsMLy8AcTtj6kf96eOrQ13vC9E6BfwGoZwyoNabxXqgZz2BA8cXAkVYbHiJ4tKAga/8S2XSIUPaNbF3QAAACZBnw5FFSwj/wAAGmmDzbcVzK8C+UF0kZ00BNhhRTTNcDcynrsNdwAAABsBny10R/8AAAMCOr+Ft4Ep2QS0Z22dVf5GXX8AAAAbAZ8vakf/AAAqCYBw3KDXFx6ZZx+uqqg+d5lwAAAAYEGbNEmoQWyZTAhP//3xAAADAxCV+nm4BNfLfpKtEnx7hRQ0hsMV9oZ1f9u0nB6ChQRCsnME0raJ4rbd07LrtVRB2NCscsni97/FW0HuMTJFQJRbLMDW7G0F0P+Iy8W3IAAAAB9Bn1JFFSwj/wAAGm2E4gRl7+/mS2uEQyTt+MpiCAmXAAAAIAGfcXRH/wAAKgBYNQFZf3I13sjbIrJqZFO5XMaPXOvwAAAAEAGfc2pH/wAAKhmEuqgAPmAAAABUQZt4SahBbJlMCE///fEAAAMDD0yb7STNZfBdoDGcVX9hvOtUt6HwkGOAAUfDR2GWULvDGDgWSrzMJQbpBbnag348useOgZWQ8PLND+vAiiLabODxAAAAIUGflkUVLCP/AAAaYIe3DbkcL+XQ17GS7lJ3SRVIgFONUAAAABwBn7V0R/8AACoCk02EKcvIpAgRnrkaA90L8yrvAAAALgGft2pH/wAAKh14zEAHGvguJxBsuEY5rk/gXacORIG1Eqcpis3/hwJhAB/1dScAAAA6QZu8SahBbJlMCE///fEAAAMDEKkHwGeLwBywO1W7nMuTBO3vVbKsc0SSUAberM8QSuKHKgBNMJnUSAAAACtBn9pFFSwj/wAAGmKYVYpX5qAEy8MmrggwCocs3aBC3n43sAvxYNmGe7GrAAAAFQGf+XRH/wAAKgBZozgQkzhDH2wKaAAAACYBn/tqR/8AAAMCOyKwcRVk9JafiuAFu/jU+rN75xR83lA3KVhhkwAAAD1Bm+BJqEFsmUwIT//98QAAAwMQEBdSUoyEgXJgQHegtumy9lHI3HN6gZze3TnEjgUjf7CS0ZrZcN7MSi4pAAAAI0GeHkUVLCP/AAAaa6nhLVhMDaUWj/d6SNRyqvkaXOFPCzcOAAAAGgGePXRH/wAAKgLbzJY+P6vJOlb2fhhkBoV3AAAAHwGeP2pH/wAAKiNmqGyb+Gdp9JScFLyIUY31q3P8l3EAAABEQZokSahBbJlMCEf//eEAAATUuXRsXJN+o1JOehpRlZPH7yxAC10EghIdvOr8Gu9e7bd6c42BhU8ItArve+GJ1AsWXkQAAAAwQZ5CRRUsI/8AABprm85n8wrB4AJ1PlexJ77sCKXs95y0PAjVLfHcV9dhFVabPsEPAAAAFwGeYXRH/wAAKgBZozgJAXNS6tv4+TMwAAAAIQGeY2pH/wAAKgn82dgoQPtOdox1jzsD+4CRzWQMoREy2QAAACpBmmZJqEFsmUwUTCP//eEAAATTc5Lvm9GarswagxMui9pxhMTVA3mKbD0AAAAsAZ6Fakf/AAAp79rogQAcbsVDQTJf38hCDEmQ6qx4Za1hntx5a/3lJAxO03sAAAAwQZqISeEKUmUwUsf//IQAABLTXpLNz1sbZamJl8AauB+EAA9609JLp4X8YWfzDRmRAAAAFwGep2pH/wAAKgVV7oevM3f9yb4rHp3QAAAMf21vb3YAAABsbXZoZAAAAAAAAAAAAAAAAAAAA+gAAA+0AAEAAAEAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAIAAAupdHJhawAAAFx0a2hkAAAAAwAAAAAAAAAAAAAAAQAAAAAAAA+0AAAAAAAAAAAAAAAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAQAAAAAAAAAAAAAAAAAAQAAAAAJYAAABkAAAAAAAJGVkdHMAAAAcZWxzdAAAAAAAAAABAAAPtAAAAgAAAQAAAAALIW1kaWEAAAAgbWRoZAAAAAAAAAAAAAAAAAAAMgAAAMkAVcQAAAAAAC1oZGxyAAAAAAAAAAB2aWRlAAAAAAAAAAAAAAAAVmlkZW9IYW5kbGVyAAAACsxtaW5mAAAAFHZtaGQAAAABAAAAAAAAAAAAAAAkZGluZgAAABxkcmVmAAAAAAAAAAEAAAAMdXJsIAAAAAEAAAqMc3RibAAAAJhzdHNkAAAAAAAAAAEAAACIYXZjMQAAAAAAAAABAAAAAAAAAAAAAAAAAAAAAAJYAZAASAAAAEgAAAAAAAAAAQAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAABj//wAAADJhdmNDAWQAH//hABlnZAAfrNlAmDPl4QAAAwABAAADAGQPGDGWAQAGaOvjyyLAAAAAGHN0dHMAAAAAAAAAAQAAAMkAAAEAAAAAFHN0c3MAAAAAAAAAAQAAAAEAAAZYY3R0cwAAAAAAAADJAAAAAQAAAgAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAAAwAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAUAAAAAAQAAAgAAAAABAAAAAAAAAAEAAAEAAAAAAQAABQAAAAABAAACAAAAAAEAAAAAAAAAAQAAAQAAAAABAAAFAAAAAAEAAAIAAAAAAQAAAAAAAAABAAABAAAAAAEAAAMAAAAAAQAAAQAAAAABAAADAAAAAAEAAAEAAAAAHHN0c2MAAAAAAAAAAQAAAAEAAADJAAAAAQAAAzhzdHN6AAAAAAAAAAAAAADJAAAE7QAAAMQAAABhAAAANQAAAD8AAACZAAAATQAAACsAAAAyAAAAaQAAAEAAAAAxAAAANAAAAG4AAABfAAAAOwAAADYAAACFAAAAXwAAAEsAAABEAAAAowAAAFoAAABDAAAAPgAAAE0AAABaAAAANAAAAEEAAABsAAAAUwAAAC8AAAAtAAAAmgAAAC0AAABNAAAAMQAAADUAAAAlAAAAUAAAACgAAAAlAAAAJAAAAI0AAABDAAAALAAAAEYAAACGAAAAPgAAAEIAAAA8AAAAawAAAFMAAAA1AAAAPwAAAHAAAABJAAAAPQAAADQAAABnAAAARQAAAEMAAABCAAAAWwAAAFoAAAA9AAAANwAAAGYAAAAvAAAANwAAADMAAACMAAAASAAAADsAAABBAAAAXgAAAEQAAAA2AAAAKQAAAEYAAAA3AAAAMwAAACkAAABCAAAAQAAAACkAAAAnAAAAVQAAADEAAAAzAAAAIQAAAFsAAAArAAAANwAAACIAAABPAAAALQAAAF4AAAApAAAAKQAAAC4AAABSAAAALAAAABsAAAAgAAAAZAAAADkAAAAzAAAAIAAAAGwAAABQAAAARgAAAEQAAABdAAAASgAAADkAAAAnAAAAXAAAAEQAAAAwAAAALgAAAE8AAABAAAAAJAAAACkAAABVAAAAKQAAADEAAAAqAAAAeAAAAE0AAAAsAAAAMQAAAG0AAAA5AAAALAAAABgAAAA7AAAALgAAACgAAAAfAAAAPQAAAC8AAAAfAAAAHwAAADkAAAAuAAAAIwAAAB8AAABFAAAAUgAAACIAAAAzAAAATAAAADwAAAAwAAAAMQAAAHgAAAAvAAAAKwAAACQAAABSAAAANAAAADYAAAApAAAARQAAACoAAAApAAAAKwAAAE8AAAAjAAAANAAAABkAAABSAAAAKgAAAB8AAAAfAAAAZAAAACMAAAAkAAAAFAAAAFgAAAAlAAAAIAAAADIAAAA+AAAALwAAABkAAAAqAAAAQQAAACcAAAAeAAAAIwAAAEgAAAA0AAAAGwAAACUAAAAuAAAAMAAAADQAAAAbAAAAFHN0Y28AAAAAAAAAAQAAADAAAABidWR0YQAAAFptZXRhAAAAAAAAACFoZGxyAAAAAAAAAABtZGlyYXBwbAAAAAAAAAAAAAAAAC1pbHN0AAAAJal0b28AAAAdZGF0YQAAAAEAAAAATGF2ZjU3LjgzLjEwMA==\" type=\"video/mp4\" />\n",
       "        </video>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.core.display.HTML object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import base64\n",
    "import glob\n",
    "import io\n",
    "import os\n",
    "\n",
    "from IPython.display import HTML, display\n",
    "\n",
    "\n",
    "def ipython_show_video(path: str) -> None:\n",
    "    \"\"\"Show a video at `path` within IPython Notebook.\"\"\"\n",
    "    if not os.path.isfile(path):\n",
    "        raise NameError(\"Cannot access: {}\".format(path))\n",
    "\n",
    "    video = io.open(path, \"r+b\").read()\n",
    "    encoded = base64.b64encode(video)\n",
    "\n",
    "    display(HTML(\n",
    "        data=\"\"\"\n",
    "        <video alt=\"test\" controls>\n",
    "        <source src=\"data:video/mp4;base64,{0}\" type=\"video/mp4\"/>\n",
    "        </video>\n",
    "        \"\"\".format(encoded.decode(\"ascii\"))\n",
    "    ))\n",
    "\n",
    "list_of_files = glob.glob(\"videos/*.mp4\")\n",
    "latest_file = max(list_of_files, key=os.path.getctime)\n",
    "print(latest_file)\n",
    "ipython_show_video(latest_file)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
